[MANUAL] German:

- sync to r19759

git-svn-id: http://framework.zend.com/svn/framework/standard/trunk@19821 44c647ce-9c0f-0410-b52a-842ac1e357ba

documentation/manual/de/manual.xml.in

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 19722 -->
+<!-- EN-Revision: 19738 -->
 <!-- Reviewed: no -->
 <!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.4//EN"
     "@DOCBOOK_DTD@"
@@ -204,6 +204,7 @@
         <xi:include href="module_specs/Zend_Feed-ModifyingFeed.xml" />
         <xi:include href="module_specs/Zend_Feed-CustomFeed.xml" />
         <xi:include href="module_specs/Zend_Feed_Reader.xml" />
+        <xi:include href="module_specs/Zend_Feed_Writer.xml" />
     </chapter>
 
     <chapter id="zend.file">
@@ -534,6 +535,13 @@
         <xi:include href="module_specs/Zend_TimeSync-Working.xml" />
     </chapter>
 
+    <chapter id="zend.tool">
+        <title>Zend_Tool</title>
+        <xi:include href="module_specs/Zend_Tool-Usage-CLI.xml" />
+        <xi:include href="module_specs/Zend_Tool-Extending.xml" />
+    </chapter>
+
+    <!--
     <chapter id="zend.tool.framework">
         <title>Zend_Tool_Framework</title>
         <xi:include href="module_specs/Zend_Tool_Framework-Introduction.xml" />
@@ -549,8 +557,9 @@
         <xi:include href="module_specs/Zend_Tool_Project.xml" />
         <xi:include href="module_specs/Zend_Tool_Project-CreateProject.xml" />
         <xi:include href="module_specs/Zend_Tool_Project-Providers.xml" />
-        <!-- <xi:include href="module_specs/Zend_Tool_Project-Internals.xml" /> -->
+        <xi:include href="module_specs/Zend_Tool_Project-Internals.xml" />
     </chapter>
+    -->
 
     <chapter id="zend.translate">
         <title>Zend_Translate</title>
@@ -627,6 +636,7 @@
         <xi:include href="ref/performance-localization.xml" />
         <xi:include href="ref/performance-view.xml" />
     </appendix>
+
     <xi:include href="ref/copyrights.xml" />
     <index id="the.index" />
 </book>

documentation/manual/de/module_specs/Zend_Barcode-Introduction.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 19695 -->
+<!-- EN-Revision: 19731 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.barcode.introduction">
     <title>Einführung</title>

documentation/manual/de/module_specs/Zend_Controller-Router-Route-Rest.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 19483 -->
+<!-- EN-Revision: 19753 -->
 <!-- Reviewed: no -->
 <sect3 id="zend.controller.router.routes.rest">
     <title>Zend_Rest_Route</title>
@@ -57,12 +57,12 @@
                 </row>
                 <row>
                     <entry><constant>POST</constant></entry>
-                    <entry><command>/product/ratings/:id?_method="PUT"</command></entry>
+                    <entry><filename>/product/ratings/:id?_method="PUT"</filename></entry>
                     <entry><methodname>Product_RatingsController::putAction()</methodname></entry>
                 </row>
                 <row>
                     <entry><constant>POST</constant></entry>
-                    <entry><command>/product/ratings/:id?_method="DELETE"</command></entry>
+                    <entry><filename>/product/ratings/:id?_method="DELETE"</filename></entry>
                     <entry>
                         <methodname>Product_RatingsController::deleteAction()</methodname>
                     </entry>

documentation/manual/de/module_specs/Zend_Feed_Reader.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 19419 -->
+<!-- EN-Revision: 19742 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.feed.reader">
     <title>Zend_Feed_Reader</title>
@@ -61,7 +61,7 @@
             die einer anderen Ideologie folgt die darin fokusiert ist einfach verwendbar zu sein,
             flexibel, konsistent und durch das Plugin System erweiterbar.
             <classname>Zend_Feed_Reader</classname> ist auch nicht dazu fähig Feeds zu erstellen,
-            das wird aber zu einem späteren Zeitpunkt hinzugefügt.
+            delegiert diese Aufgabe aber an <classname>Zend_Feed_Writer</classname>, seinen Bruder.
         </para>
     </sect2>
 
@@ -106,7 +106,7 @@ foreach ($feed as $entry) {
         'title'        => $entry->getTitle(),
         'description'  => $entry->getDescription(),
         'dateModified' => $entry->getDateModified(),
-        'author'       => $entry->getAuthor(),
+        'authors'      => $entry->getAuthors(),
         'link'         => $entry->getLink(),
         'content'      => $entry->getContent()
     );
@@ -375,11 +375,14 @@ $feed = Zend_Feed_Reader::import(
         </para>
 
         <para>
-            Das zurückgegebene Objekt ist ein <classname>ArrayObject</classname> welches
-            <classname>Zend_Feed_Reader_FeedSet</classname> heisst, damit es in ein Array gecastet
-            werden kann, oder damit man es iterieren kann um auf alle erkannten Links zuzugreifen.
-            Trotzdem kann man, als einfache Abkürzung, den ersten RSS, RDF oder Atom Link holen
-            indem dessen öffentliche Eigenschaft wie im beiliegenden Beispiel verwendet wird.
+            Das zurückgegebene Objekt ist eine Unterklasse von <classname>ArrayObject</classname>
+            welche <classname>Zend_Feed_Reader_Collection_FeedLink</classname> heisst, damit es in
+            ein Array gecastet werden kann, oder damit man es iterieren kann um auf alle erkannten
+            Links zuzugreifen. Trotzdem kann man, als einfache Abkürzung, den ersten RSS, RDF oder
+            Atom Link holen indem dessen öffentliche Eigenschaft wie im beiliegenden Beispiel
+            verwendet wird. Andernfalls ist jedes Element von <classname>ArrayObject</classname>
+            ein einfaches Array mit den Schlüsseln "type" und "uri" wobei der Typ "rdf", "rss" oder
+            "atom" sein kann.
         </para>
 
         <programlisting language="php"><![CDATA[
@@ -412,21 +415,9 @@ if(isset($links->atom)) {
 $links = Zend_Feed_Reader::findFeedLinks('http://www.planet-php.net');
 
 foreach ($links as $link) {
-    echo $link['href'], "\n";
+    echo $link['uri'], "\n";
 }
 ]]></programlisting>
-
-        <para>
-            Die möglichen Schlüssel sind <emphasis>href</emphasis>, <emphasis>rel</emphasis> der
-            immer 'alternate' ist, <emphasis>type</emphasis> welcher
-            <code>application/rss+xml</code>, <code>application/rdf+xml</code> oder
-            <code>application/atom+xml</code> ist, und <emphasis>feed</emphasis>.
-            <emphasis>feed</emphasis>. ist nur vorhanden wenn man <classname>ArrayObject</classname>
-            erhält (es also nicht in ein Array castet) und dessen Verwendung führt zu einem
-            Versuch den Feed in eine <classname>Zend_Feed_Reader_FeedAbstract</classname> Instanz
-            zu laden. Das ist ein Versuch des Lazy Loadings - Feeds werden trotzdem geladen sobald
-            man versucht auf Sie zuzugreifen indem diese Methode verwendet wird.
-        </para>
   </sect2>
 
     <sect2 id="zend.feed.reader.attribute-collections">
@@ -464,7 +455,9 @@ foreach ($links as $link) {
             Objekt wird, für jede Kategorie, drei Felder an Daten enthalten: term, schema und label.
             "term" ist der grundsätzliche Name der Kategorie, oft Maschinen lesbar (normalerweise
             ein URI Identifikator) und in RSS 2.0 auch bekannt als "domain". "label" ist ein
-            menschlich lesbarer Kategorie Name welcher Html Entities unterstützt.
+            menschlich lesbarer Kategorie Name welcher Html Entities unterstützt. In RSS 2.0 gibt es
+            kein Label Attribut deshalb wird es der Bequemlichkeit halber  immer auf den selben Wert
+            gesetzt wie der Ausdruck.
         </para>
 
         <para>
@@ -491,7 +484,7 @@ foreach ($categories as $cat) {
             einfaches Array indem die Methode <methodname>getValues()</methodname> verwendet wird.
             Das Konzept der "relevantesten" Daten ist offensichtlich ein beurteilter Aufruf. Für
             Kategorien bedeutet es die Label der Kategorien (nicht die Typen oder Schemata) wärend
-            es für Autoren der Name des Autors wäre (nicht deren Email Adressen oder die URLs). Das
+            es für Autoren der Name des Autors wäre (nicht deren Email Adressen oder die URIs). Das
             einfache Array ist flach (nur Werte) und durchläuft
             <methodname>array_unique</methodname> um doppelte Werte zu entfernen.
         </para>
@@ -528,6 +521,20 @@ $labels = $categories->getValues();
             die man benötigt.
         </para>
 
+        <note>
+            <para>
+                Wärend die Erkennung von Gemeinsamkeiten zwischen den Feed Typen selbst sehr komplex
+                ist, sollte erwähnt werden das RSS selbst eine konstant strittige "Spezifikation".
+                Das hat seine Wurzeln im originalen RSS 2.0 Dokument welches Doppeldeutigkeiten
+                enthält und die richtige Behandlung alle Elemente nicht im Detail erklärt. Als
+                Ergebnis verwendet diese Komponente riguros die RSS 2.0.11 Spezifikation welche vom
+                RSS Advisory Board veröffentlicht wurde und dessen beigefügtes RSS Best Practices
+                Profil. Keine andere Interpretation von RSS 2.0 wird unterstützt wobei Ausnahmen
+                erlaubt sein können wo es die anwendung der zwei vorher erwähnten Dokumente nicht
+                direkt verhindert.
+            </para>
+        </note>
+
         <para>
             Natürlich leben wir nicht in einer idealen Welt sodas es Zeiten gibt in denen die
             <acronym>API</acronym> einfach nicht das bietet wonach man sucht. Um hierbei zu helfen
@@ -537,7 +544,8 @@ $labels = $categories->getValues();
             einer weiteren Erweiterung zu problematisch ist, kann man einfach das darunterliegende
             <acronym>DOM</acronym> oder die XPath Objekte holen und das von Hand in der Anwendung
             machen. Natürlich sollte wirklich eine Erweiterung geschrieben werden, einfach um es
-            portabler und wiederverwendbarer zu machen.
+            portabler und wiederverwendbarer zu machen. Und nützliche Erweiterungen können für den
+            Framework vorgeschlagen werden um Sie formal hinzuzufügen.
         </para>
 
         <para>
@@ -593,8 +601,10 @@ $labels = $categories->getValues();
 
                         <entry>
                             Gibt die <acronym>URI</acronym> dieses Feeds zurück, welche die gleiche
-                            sein sollte wie die <acronym>URI</acronym> welche verwendet wurde um
-                            den Feed zu importieren
+                            sein kann wie die <acronym>URI</acronym> welche verwendet wurde um
+                            den Feed zu importieren. Es gibt wichtige Fälle in denen sich der Feed
+                            Link unterscheiden kann weil die Quell URI aktualisiert wird und
+                            geplant ist Sie in Zukunft zu entfernen.
                         </entry>
                     </row>
 
@@ -602,8 +612,12 @@ $labels = $categories->getValues();
                         <entry><methodname>getAuthors()</methodname></entry>
 
                         <entry>
-                            Gibt ein Array aller Authoren zurück die mit diesem Feed assoziiert
-                            sind, inklusive Email Adressen im String des Authors wenn vorhanden
+                            Gibt ein Objekt vom Typ
+                            <classname>Zend_Feed_Reader_Collection_Author</classname> zurück welches
+                            ein <classname>ArrayObject</classname> ist dessen Elemente einfach
+                            Arrays sind die eine Kombination der Schlüssel "name", "email" und
+                            uri" enthalten. Wo es wegen der Quelldaten irrelevant ist können
+                            einige dieser Schlüssel unterdrückt werden.
                         </entry>
                     </row>
 
@@ -613,8 +627,8 @@ $labels = $categories->getValues();
                         <entry>
                             Gibt entweder den ersten bekannten Author zurück, oder mit dem
                             optionalen Parameter <varname>$index</varname> jeden spezifischen
-                            Index des Arrays von Authoren (gibt null bei einem ungültigen Index
-                            zurück).
+                            Index des Arrays von Authoren wie vorher beschrieben (gibt null bei
+                            einem ungültigen Index zurück).
                         </entry>
                     </row>
 
@@ -624,7 +638,8 @@ $labels = $categories->getValues();
                         <entry>
                             Gibt das Datum zurück zu dem dieser Feed erstellt wurde. Generell nur
                             anwendbar bei Atom da es das Datum repräsentiert zu der das Atom 1.0
-                            Dokument erstellt wurde das die Ressource beschreibt.
+                            Dokument erstellt wurde das die Ressource beschreibt. Das zurückgegebene
+                            Datum ist ein <classname>Zend_Date</classname> Objekt.
                         </entry>
                     </row>
 
@@ -632,7 +647,8 @@ $labels = $categories->getValues();
                         <entry><methodname>getDateModified()</methodname></entry>
 
                         <entry>
-                            Gibt das Datum zurück zu dem der Feed das letzte mal geändert wurde
+                            Gibt das Datum zurück zu dem der Feed das letzte mal geändert wurde. Das
+                            zurückgegebene Datum ist ein <classname>Zend_Date</classname> Objekt.
                         </entry>
                     </row>
 
@@ -649,7 +665,7 @@ $labels = $categories->getValues();
                         <entry><methodname>getGenerator()</methodname></entry>
 
                         <entry>
-                            Gibt den Erzeuger des Feeds zurück, z.B. die Software die Ihm erzeugt
+                            Gibt den Erzeuger des Feeds zurück, z.B. die Software die Ihn erzeugt
                             hat. Das kann sich zwischen <acronym>RSS</acronym> und Atom
                             unterscheiden, da Atom eine andere Schreibweise definiert.
                         </entry>
@@ -786,7 +802,9 @@ $labels = $categories->getValues();
                         <entry>
                             Gibt die Kodierung des <acronym>XML</acronym> Quelldokuments zurück
                             (Beachte: Das kann nicht verwendet werden für Fehler wie einen
-                            Server der Dokumente in einer anderen Kodierung verschickt)
+                            Server der Dokumente in einer anderen Kodierung verschickt). Wo diese
+                            nicht definiert ist, wird die Standardkodierung UTF-8 von Unicode
+                            angewendet.
                         </entry>
                     </row>
 
@@ -895,19 +913,19 @@ $labels = $categories->getValues();
                     <row>
                         <entry><methodname>getId()</methodname></entry>
 
-                        <entry>Gibt eine eindeutige ID für den aktuellen Eintrag zurück</entry>
+                        <entry>Gibt eine eindeutige ID für den aktuellen Eintrag zurück.</entry>
                     </row>
 
                     <row>
                         <entry><methodname>getTitle()</methodname></entry>
 
-                        <entry>Gibt den Titel des aktuellen Eintrags zurück</entry>
+                        <entry>Gibt den Titel des aktuellen Eintrags zurück.</entry>
                     </row>
 
                     <row>
                         <entry><methodname>getDescription()</methodname></entry>
 
-                        <entry>Gibt eine Beschreibung des aktuellen Eintrags zurück</entry>
+                        <entry>Gibt eine Beschreibung des aktuellen Eintrags zurück.</entry>
                     </row>
 
                     <row>
@@ -915,7 +933,7 @@ $labels = $categories->getValues();
 
                         <entry>
                             Gibt eine <acronym>URI</acronym> zur <acronym>HTML</acronym> Version des
-                            aktuellen Eintrags zurück
+                            aktuellen Eintrags zurück.
                         </entry>
                     </row>
 
@@ -923,7 +941,9 @@ $labels = $categories->getValues();
                         <entry><methodname>getPermaLink()</methodname></entry>
 
                         <entry>
-                            Gibt einen permanenten Link zum aktuellen Eintrag zurück
+                            Gibt einen permanenten Link zum aktuellen Eintrag zurück. In den meisten
+                            Fällen ist dies das selbe wie die Verwendung von
+                            <methodname>getLink()</methodname>.
                         </entry>
                     </row>
 
@@ -931,20 +951,23 @@ $labels = $categories->getValues();
                         <entry><methodname>getAuthors()</methodname></entry>
 
                         <entry>
-                            Gibt ein Array aller Authoren zurück die mit diesem Eintrag assoziiert
-                            sind, inklusive Email Adresse wenn diese im String des Authors vorhanden
-                            ist
+                            Gibt ein Objekt vom Typ
+                            <classname>Zend_Feed_Reader_Collection_Author</classname> zurück welches
+                            ein <classname>ArrayObject</classname> ist, dessen Elemente alle
+                            einfache Array sind welche beliebige Kombinationen der Schlüssel "name",
+                            "email" und "uri" enthalten können. Wo es für die Quelldaten irrelevant
+                            ist können einige dieser Schlüssel unterdrückt sein.
                         </entry>
                     </row>
 
                     <row>
-                        <entry><methodname>getAuthor($index = 0)</methodname></entry>
+                        <entry><methodname>getAuthor(integer $index = 0)</methodname></entry>
 
                         <entry>
-                            Gibt entweder den ersten bekannten Author zurück, oder mit dem
+                            Gibt entweder den ersten bekannten Autor zurück, oder mit dem
                             optionalen Parameter <varname>$index</varname> jeden spezifischen Index
-                            aus dem Array der Authoren (gibt null zurück wenn der Index ungültig
-                            ist).
+                            aus dem Array der Authoren wie vorher beschrieben (gibt null zurück wenn
+                            der Index ungültig ist).
                         </entry>
                     </row>
 
@@ -983,9 +1006,11 @@ $labels = $categories->getValues();
 
                         <entry>
                             Gibt ein Array zurück welches die Werte aller Attribute eines
-                            Multimedia &lt;enclosure&gt; Elements enthält, inklusive den Array
-                            Schlüsseln: <emphasis>url</emphasis>, <emphasis>length</emphasis>,
-                            <emphasis>type</emphasis>.
+                            Multimedia &lt;enclosure&gt; Elements enthält, inklusive der Array
+                            Schlüssel: <emphasis>url</emphasis>, <emphasis>length</emphasis>,
+                            <emphasis>type</emphasis>. Basierend auf dem RSS Best Practices Profile
+                            des TSS Advisory Boards, wird keine Unterstützung für mehrere Enclosures
+                            angeboten da so eine Unterstützung kein Teil der RSS Spezifikation ist.
                         </entry>
                     </row>
 
@@ -1010,8 +1035,8 @@ $labels = $categories->getValues();
 
                     <row>
                         <entry>
-                            <methodname>getCommentFeedLink(string $type =
-                                'atom'|'rss')</methodname>
+                            <methodname>getCommentFeedLink([string $type =
+                                'atom'|'rss'])</methodname>
                         </entry>
 
                         <entry>
@@ -1061,12 +1086,19 @@ $labels = $categories->getValues();
                 <methodname>getDescription()</methodname> und
                 <methodname>getContent()</methodname>. Wenn der Eintrag wirklich geändert wurde,
                 gibt diese Hash Berechnung ein anderes Ergebnis als die vorher gespeicherten Hashs
-                für den gleichen Eintrag. Weitere Schritte in diesen Wassern zeigen das die Daten
+                für den gleichen Eintrag. Das ist natürlich Inhalts-Orientiert und hilft nicht
+                bei der Erkennung von anderen relevanten Elementen. Atom Feeds sollten solche
+                Schritte nicht benötigen.
+            </para>
+
+            <para>
+                Weitere Schritte in diesen Wassern zeigen das die Daten
                 von Feeds unterschiedlichen Standards folgen. Atom und Dublin Core Daten sollten
                 <acronym>ISO</acronym> 86001 folgen und <acronym>RSS</acronym> Daten sollten
                 <acronym>RFC</acronym> 822 oder <acronym>RFC</acronym> 2822 folgen welche auch
                 üblicherweise verwendet werden. Datumsmethoden werfen eine Exception wenn
-                <classname>Zend_Date</classname> das Datum durch Verwendung der obigen Standards
+                <classname>Zend_Date</classname>, oder die PHP basierenden Möglichkeiten für
+                <acronym>RSS</acronym> Daten, das Datum durch Verwendung der obigen Standards
                 nicht laden kann.
             </para>
         </caution>
@@ -1132,7 +1164,9 @@ $labels = $categories->getValues();
                         <entry>
                             Gibt die Kodierung des <acronym>XML</acronym> Quelldokuments zurück
                             (Achtung: Das kann nicht für Fehler genommen werden bei denen der
-                            Server eine andere Kodierung sendet als die Dokumente)
+                            Server eine andere Kodierung sendet als die Dokumente). Die Standard
+                            Kodierung welche bei Abwesenheit jeglicher anderen Kodierung angewendet
+                            wird, ist die UTF-8 Kodierung von Unicode.
                         </entry>
                     </row>
 
@@ -1563,4 +1597,63 @@ $firstIsbn = $feed->current()->getIsbn();
             </para>
         </sect3>
     </sect2>
+
+    <sect2 id="migrating.from.1.9.6.to.1.10.or.later">
+        <title>Migrating from 1.9.6 to 1.10 or later</title>
+
+        <para>
+            Mit der Einführung von Zend Framework 1.10 wurde die Behandlung für das Empfangen von
+            Autoren und Entwicklern in <classname>Zend_Feed_Reader</classname> geändert. Diese
+            Änderung war ein Weg die Behandlung solcher Daten zwischen RSS und Atom Klassen zwischen
+            den Komponenten zu harmonisieren und die Rückgabe von Autoren und Entwicklern in einer
+            besseren, verwendbareren und detailuerteren Form zu ermöglichen. Das korrigiert auch
+            einen Fehler bei dem angenommen wurde das jedes Autor Element auf einen Namen zeigt.
+            In RSS ist das falsch, da ein Autor Element aktuell nur eine Email Adresse anbieten
+            muss. Zusätzlich fügte die originale Implementation seine RSS Limits bei Atom Feeds
+            hinzu was zu einer Reduzierung der Nützlichkeit des Parsers mit diesem Format führte.
+        </para>
+
+        <para>
+            Die Änderung bedeutet das Methoden wie <methodname>getAuthors()</methodname> und
+            <methodname>getContributors</methodname> nicht länger ein einfaches Array von Strings
+            zurückgeben die von den relevanten RSS und Atom Elementen geparst wurden Statt dessen
+            ist der Rückgabewert eine Unterklasse von <classname>ArrayObject</classname> die
+            <classname>Zend_Feed_Reader_Collection_Author</classname> genannt wird und ein
+            aufzählbares multidimensionales Array an Autoren simuliert. Jedes Mitglied dieses
+            Objekts ist ein einfaches Array mit drei potentiellen Schlüsseln (wie in den
+            Quelldaten erlaubt). Diese beinhalten name, email und uri.
+        </para>
+
+        <para>
+            Das originale Verhlaten dieser Methoden würde ein einfaches Array von Strings
+            zurückgeben, wobei jeder String versucht einen einzelnen Namen zu präsentieren, aber in
+            der Realität war dies nicht möglich da es keine Regel gibt die das Format der RSS
+            Autor Strings leiten.
+        </para>
+
+        <para>
+            Die einfachste Methode der Simulation des originalen Verhaltens dieser Methoden ist die
+            Verwendung von <classname>Zend_Feed_Reader_Collection_Author</classname>'s
+            <methodname>getValues()</methodname> welche auch ein einfaches Array an Strings
+            darstellt und die "relevantesten Daten" repräsentiert. Für Autoren wird deren Name
+            angenommen. Jeder Wert in resultierenden Array wird vom "name" Wert abgeleitet welcher
+            jedem Autor angehängt ist (wenn vorhanden). In den meisten Fällen ist diese einfache
+            Änderung einfach durchzuführen wie anbei demonstriert.
+        </para>
+
+        <programlisting language="php"><![CDATA[
+/**
+ * In 1.9.6
+ */
+
+$feed = Zend_Feed_Reader::import('http://example.com/feed');
+$authors = $feed->getAuthors();
+
+/**
+ * Äquivalent in 1.10
+ */
+$feed = Zend_Feed_Reader::import('http://example.com/feed');
+$authors = $feed->getAuthors()->getValues();
+]]></programlisting>
+    </sect2>
 </sect1>

documentation/manual/de/module_specs/Zend_Feed_Writer.xml

@@ -0,0 +1,545 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- EN-Revision: 19730 -->
+<!-- Reviewed: no -->
+<sect1 id="zend.feed.writer">
+    <title>Zend_Feed_Writer</title>
+
+    <sect2 id="zend.feed.writer.introduction">
+        <title>Einführung</title>
+
+        <para>
+            <classname>Zend_Feed_Writer</classname> ist die Bruderkomponente zu
+            <classname>Zend_Feed_Reader</classname> und verantwortlich für die Erzeugung von
+            Feeds für die Ausgabe. Sie unterstützt die Atom 1.0 Spezifikation (RFC 4287) und
+            RSS 2.0 wie vom RSS Advisory Board (RSS 2.0.11) spezifiziert. Es ist kein Nachkomme
+            dieser Standard. Trotzdem bietet es ein einfaches System der Erweiterung welches es
+            erlaube jede Erweiterung/Modul für jede der zwei Spezifikationen zu implementieren
+            wenn diese nicht von Haus aus angeboten werden.
+        </para>
+
+        <para>
+            Auf vielen Wegen ist <classname>Zend_Feed_Writer</classname> das Gegenteil von
+            <classname>Zend_Feed_Reader</classname>. Wobei <classname>Zend_Feed_Reader</classname>
+            darauf fokusiert ist ein einfach zu verwendendes Architektur Frontend durch Getter
+            Methoden anzubieten, und <classname>Zend_Feed_Writer</classname> durch ähnlich
+            benannte Setter oder Mutatoren. Das stellt sicher das die API keine weitere Lernkurve
+            erfordert wenn jemand bereits mit <classname>Zend_Feed_Reader</classname> bekannt ist.
+        </para>
+
+        <para>
+            Als Ergebnis dieses Designs, ist der Rest sogar einleuchtend. Dahinter, wird jedes
+            Datenset eines <classname>Zend_Feed_Reader</classname> Objekts wärend der
+            Darstellungszeit in ein <classname>DOMDocument</classname> Objekt übersetzt indem die
+            notwendigen Feed Elemente verwendet werden. Für jeden unterstützten Feed Typen gibt es
+            beide, sowohl einen Atom 1.0 als auch einen RSS 2.0 Renderer. Die Verwendung von
+            <classname>DOMDocument</classname> statt einer Template Lösung hat viele Vorteile.
+            Der offensichtlichste ist die Möglichkeit das <classname>DOMDocument</classname> zu
+            exportieren um es weiter zu bearbeiten und auf PHP DOM für die Korrakturen und
+            richtige Darstellung zu setzen.
+        </para>
+
+        <para>
+            Wie bei <classname>Zend_Feed_Reader</classname> ist
+            <classname>Zend_Feed_Writer</classname> ein alleinstehender Ersatz für
+            <classname>Zend_Feed</classname>'s Builder Architektur und nicht kompatibel mit diesen
+            Klassen.
+        </para>
+    </sect2>
+
+    <sect2 id="zend.feed.writer.architecture">
+        <title>Architektur</title>
+
+        <para>
+            Die Architektur von <classname>Zend_Feed_Writer</classname> ist sehr einfach. Es hat
+            zwei Kernsets von Klassen: Container und Renderer.
+        </para>
+
+        <para>
+            The containers include the <classname>Zend_Feed_Writer_Feed</classname> and
+            <classname>Zend_Feed_Writer_Entry</classname> classes. The Entry classes can be attached
+            to any Feed class. The sole purpose of these containers is to collect data about the
+            feed to generate using a simple interface of setter methods. These methods perform some
+            data validity testing. For example, it will validate any passed URIs, dates, etc. These
+            checks are not tied to any of the feed standards. The container objects also contain
+            methods to allow for fast rendering and export of the final feed, and these can be
+            reused at will.
+        </para>
+
+        <para>
+            While there are two data containers, there are four renderers - two matching container
+            renderers per support feed type. The renderer accept a container, and based on its
+            content attempt to generate a valid feed. If the renderer is unable to generate a valid
+            feed, perhaps due to the container missing an obligatory data point, it will report this
+            by throwing an <classname>Exception</classname>. While it is possible to ignore
+            <classname>Exception</classname>s, this removes the default safeguard of ensuring you
+            have sufficient data set to render a wholly valid feed.
+        </para>
+
+        <para>
+            Due to the system being divided between data containers and renderers, it can make
+            Extensions somewhat interesting. A typical Extension offering namespaced feed and entry
+            level elements, must itself reflect the exact same architecture, i.e. offer feed and
+            entry level data containers, and matching renderers. There is, fortunately, no complex
+            integration work required since all Extension classes are simply registered and
+            automatically used by the core classes. We'll meet Extensions in more detail at the end
+            of this section.
+        </para>
+    </sect2>
+
+    <sect2 id="zend.feed.writer.getting.started">
+        <title>Getting Started</title>
+
+        <para>
+            Using <classname>Zend_Feed_Reader</classname> is as simple as setting data and
+            triggering the renderer. Here is an example to generate a minimal Atom 1.0 feed.
+        </para>
+
+        <programlisting language="php"><![CDATA[
+/**
+ * Create the parent feed
+ */
+$feed = new Zend_Feed_Writer_Feed;
+$feed->setTitle('Paddy\'s Blog');
+$feed->setLink('http://www.example.com');
+$feed->setFeedLink('http://www.example.com/atom', 'atom');
+$feed->addAuthor(array(
+    'name'  => 'Paddy',
+    'email' => 'paddy@example.com',
+    'uri'   => 'http://www.example.com',
+));
+$feed->setDateModified(time());
+$feed->addHub('http://pubsubhubbub.appspot.com/');
+
+/**
+ * Add one or more entries. Note that entries must
+ * be manually added once created.
+ */
+$entry = $feed->createEntry();
+$entry->setTitle('All Your Base Are Belong To Us');
+$entry->setLink('http://www.example.com/all-your-base-are-belong-to-us');
+$entry->addAuthor(array(
+    'name'  => 'Paddy',
+    'email' => 'paddy@example.com',
+    'uri'   => 'http://www.example.com',
+));
+$entry->setDateModified(time());
+$entry->setDateCreated(time());
+$entry->setDescription('Exposing the difficultly of porting games to English.');
+$entry->setContent('I am not writing the article. The example is long enough as is ;).');
+$feed->addEntry($entry);
+
+/**
+ * Render the resulting feed to Atom 1.0 and assign to $out.
+ * You can substitute "atom" with "rss" to generate an RSS 2.0 feed.
+ */
+$out = $feed->export('atom');
+]]></programlisting>
+
+        <para>
+            The output rendered should be as follows:
+        </para>
+
+        <programlisting language="xml">
+&#60;?xml version="1.0" encoding="utf-8"?&#62;
+&#60;feed xmlns="http://www.w3.org/2005/Atom"&#62;
+    &#60;title type="text"&#62;Paddy's Blog&#60;/title&#62;
+    &#60;subtitle type="text"&#62;Writing about PC Games since 176 BC.&#60;/subtitle&#62;
+    &#60;updated&#62;2009-12-14T20:28:18+00:00&#60;/updated&#62;
+    &#60;generator uri="http://framework.zend.com" version="1.10.0alpha"&#62;
+        Zend_Feed_Writer
+    &#60;/generator&#62;
+    &#60;link rel="alternate" type="text/html" href="http://www.example.com"/&#62;
+    &#60;link rel="self" type="application/atom+xml" href="http://www.example.com/atom"/&#62;
+    &#60;id&#62;http://www.example.com&#60;/id&#62;
+    &#60;author&#62;
+        &#60;name&#62;Paddy&#60;/name&#62;
+        &#60;email&#62;paddy@example.com&#60;/email&#62;
+        &#60;uri&#62;http://www.example.com&#60;/uri&#62;
+    &#60;/author&#62;
+    &#60;link rel="hub" href="http://pubsubhubbub.appspot.com/"/&#62;
+    &#60;entry&#62;
+        &#60;title type="html"&#62;&#60;![CDATA[All Your Base Are Belong To Us]]&#62;&#60;/title&#62;
+        &#60;summary type="html"&#62;
+            &#60;![CDATA[Exposing the difficultly of porting games to English.]]&#62;
+        &#60;/summary&#62;
+        &#60;published&#62;2009-12-14T20:28:18+00:00&#60;/published&#62;
+        &#60;updated&#62;2009-12-14T20:28:18+00:00&#60;/updated&#62;
+        &#60;link rel="alternate" type="text/html" href="http://www.example.com/all-your-base-are-belong-to-us"/&#62;
+        &#60;id&#62;http://www.example.com/all-your-base-are-belong-to-us&#60;/id&#62;
+        &#60;author&#62;
+        &#60;name&#62;Paddy&#60;/name&#62;
+        &#60;email&#62;paddy@example.com&#60;/email&#62;
+        &#60;uri&#62;http://www.example.com&#60;/uri&#62;
+        &#60;/author&#62;
+        &#60;content type="html"&#62;
+            &#60;![CDATA[I am not writing the article. The example is long enough as is ;).]]&#62;
+        &#60;/content&#62;
+    &#60;/entry&#62;
+&#60;/feed&#62;
+</programlisting>
+
+        <para>
+            This is a perfectly valid Atom 1.0 example. It should be noted that omitting an obligatory point
+            of data, such as a title, will trigger an <classname>Exception</classname> when
+            rendering as Atom 1.0. This will differ for RSS 2.0 since a title may be omitted so long
+            as a description is present. This gives rise to Exceptions that differ between the two
+            standards depending on the renderer in use. By design,
+            <classname>Zend_Feed_Writer</classname> will not render an invalid feed for either
+            standard unless the end-user deliberately elects to ignore all Exceptions.
+        </para>
+    </sect2>
+
+    <sect2 id="zend.feed.writer.setting.feed.data.points">
+        <title>Setting Feed Data Points</title>
+
+        <para>
+            Before you can render a feed, you must first setup the data necessary for
+            the feed being rendered. This utilises a simple setter style API which doubles
+            as an initial method for validating the data being set. By design, the API
+            closely matches that for <classname>Zend_Feed_Reader</classname> to avoid
+            undue confusion and uncertainty.
+        </para>
+
+        <para>
+            <classname>Zend_Feed_Writer</classname> offers this API via its data container
+            classes <classname>Zend_Feed_Writer_Feed</classname> and
+            <classname>Zend_Feed_Writer_Entry</classname>. These classes merely store
+            all feed data in type-agnostic manner, meaning you may reuse any data
+            container with any renderer without requiring additional work. Both classes
+            are also amenable to Extensions, meaning that an Extension may define its own
+            container classes which are registered to the base container classes as extensions, and
+            are checked when any method call triggers the base container's
+            <methodname>__call()</methodname> method.
+        </para>
+
+        <para>
+            Here's a summary of the Core <acronym>API</acronym> for Feeds. You should note it
+            comprises not only the basic <acronym>RSS</acronym> and Atom standards, but also
+            accounts for a number of included Extensions bundled with
+            <classname>Zend_Feed_Writer</classname>. The naming of these
+            Extension sourced methods remain fairly generic - all Extension
+            methods operate at the same level as the Core <acronym>API</acronym> though we do allow
+            you to retrieve any specific Extension object separately if required.
+        </para>
+
+        <table>
+            <title>Feed Level API Methods</title>
+
+            <tgroup cols="2">
+                <tbody>
+                    <row>
+                        <entry><methodname>setId()</methodname></entry>
+
+                        <entry>Set a unique ID associated with this feed. For Atom 1.0
+                        this is an atom:id element, whereas for RSS 2.0 it is added
+                        as a guid element. These are optional so long as a link is
+                        added, i.e. the link is set as the ID.</entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setTitle()</methodname></entry>
+
+                        <entry>Set the title of the feed.</entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setDescription()</methodname></entry>
+
+                        <entry>Set the text description of the feed.</entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setLink()</methodname></entry>
+
+                        <entry>
+                            Set a <acronym>URI</acronym> to the <acronym>HTML</acronym> website
+                            containing the same or
+                            similar information as this feed (i.e. if the feed is from a blog,
+                            it should provide the blog's <acronym>URI</acronym> where the
+                            <acronym>HTML</acronym> version of the entries can be read).
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setFeedLinks()</methodname></entry>
+
+                        <entry>
+                            Add a link to an XML feed, whether the feed being generated or
+                            an alternate URI pointing to the same feed but in a different
+                            format. At a minimum, it is recommended to include a link to
+                            the feed being generated so it has an identifiable final
+                            URI allowing a client to track its location changes without
+                            necessitating constant redirects. The parameter is an array of
+                            arrays, where each sub-array contains the keys "type" and "uri".
+                            The type should be one of "atom", "rss", or "rdf". If a type is
+                            omitted, it defaults to the type used when rendering the feed.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setAuthors()</methodname></entry>
+
+                        <entry>
+                            Sets the data for authors. The parameter is an array of arrays
+                            where each sub-array may contain the keys "name", "email" and
+                            "uri". The "uri" value is only applicable for Atom feeds since
+                            RSS contains no facility to show it. For RSS 2.0, rendering will
+                            create two elements - an author element containing the email
+                            reference with the name in brackets, and a Dublin Core creator
+                            element only containing the name.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setAuthor()</methodname></entry>
+
+                        <entry>
+                            Sets the data for a single author following the same
+                            format as described above for a single sub-array.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setDateCreated()</methodname></entry>
+
+                        <entry>
+                            Sets the date on which this feed was created. Generally
+                            only applicable to Atom where it represents the date the resource
+                            described by an Atom 1.0 document was created. The expected parameter
+                            may be a UNIX timestamp or a <classname>Zend_Date</classname> object.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>getDateModified()</methodname></entry>
+
+                        <entry>
+                            Sets the date on which this feed was last modified. The expected parameter
+                            may be a UNIX timestamp or a <classname>Zend_Date</classname> object.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setLanguage()</methodname></entry>
+
+                        <entry>
+                            Sets the language of the feed. This will be omitted unless set.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>getGenerator()</methodname></entry>
+
+                        <entry>
+                            Allows the setting of a generator. The parameter should be an
+                            array containing the keys "name", "version" and "uri". If omitted
+                            a default generator will be added referencing
+                            <classname>Zend_Feed_Writer</classname>, the current Zend Framework
+                            version and the Framework's URI.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setCopyright()</methodname></entry>
+
+                        <entry>
+                            Sets a copyright notice associated with the feed.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setHubs()</methodname></entry>
+
+                        <entry>
+                            Accepts an array of Pubsubhubbub Hub Endpoints to be rendered in
+                            the feed as Atom links so that PuSH Subscribers may subscribe to
+                            your feed. Note that you must implement a Pubsubhubbub Publisher in
+                            order for real-time updates to be enabled. A Publisher may be implemented
+                            using <classname>Zend_Feed_Pubsubhubbub_Publisher</classname>.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setCategories()</methodname></entry>
+
+                        <entry>
+                            Accepts an array of categories for rendering, where each element is itself
+                            an array whose possible keys include "term", "label" and "scheme". The "term"
+                            is a typically a category name suitable for inclusion in a URI. The "label"
+                            may be a human readable category name supporting special characters (it is encoded
+                            during rendering) and is a required key. The "scheme" (called the domain in RSS)
+                            is optional but must be a valid URI.
+                        </entry>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
+    </sect2>
+
+    <sect2 id="zend.feed.writer.setting.entry.data.points">
+        <title>Setting Entry Data Points</title>
+
+        <para>
+            Here's a summary of the Core <acronym>API</acronym> for Entries/Items. You should note it
+            comprises not only the basic <acronym>RSS</acronym> and Atom standards, but also
+            accounts for a number of included Extensions bundled with
+            <classname>Zend_Feed_Writer</classname>. The naming of these
+            Extension sourced methods remain fairly generic - all Extension
+            methods operate at the same level as the Core <acronym>API</acronym> though we do allow
+            you to retrieve any specific Extension object separately if required.
+        </para>
+
+        <table>
+            <title>Entry Level API Methods</title>
+
+            <tgroup cols="2">
+                <tbody>
+                    <row>
+                        <entry><methodname>setId()</methodname></entry>
+
+                        <entry>Set a unique ID associated with this feed. For Atom 1.0
+                        this is an atom:id element, whereas for RSS 2.0 it is added
+                        as a guid element. These are optional so long as a link is
+                        added, i.e. the link is set as the ID.</entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setTitle()</methodname></entry>
+
+                        <entry>Set the title of the feed.</entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setDescription()</methodname></entry>
+
+                        <entry>Set the text description of the feed.</entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setLink()</methodname></entry>
+
+                        <entry>
+                            Set a <acronym>URI</acronym> to the <acronym>HTML</acronym> website
+                            containing the same or
+                            similar information as this feed (i.e. if the feed is from a blog,
+                            it should provide the blog's <acronym>URI</acronym> where the
+                            <acronym>HTML</acronym> version of the entries can be read).
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setFeedLinks()</methodname></entry>
+
+                        <entry>
+                            Add a link to an XML feed, whether the feed being generated or
+                            an alternate URI pointing to the same feed but in a different
+                            format. At a minimum, it is recommended to include a link to
+                            the feed being generated so it has an identifiable final
+                            URI allowing a client to track its location changes without
+                            necessitating constant redirects. The parameter is an array of
+                            arrays, where each sub-array contains the keys "type" and "uri".
+                            The type should be one of "atom", "rss", or "rdf". If a type is
+                            omitted, it defaults to the type used when rendering the feed.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setAuthors()</methodname></entry>
+
+                        <entry>
+                            Sets the data for authors. The parameter is an array of arrays
+                            where each sub-array may contain the keys "name", "email" and
+                            "uri". The "uri" value is only applicable for Atom feeds since
+                            RSS contains no facility to show it. For RSS 2.0, rendering will
+                            create two elements - an author element containing the email
+                            reference with the name in brackets, and a Dublin Core creator
+                            element only containing the name.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setAuthor()</methodname></entry>
+
+                        <entry>
+                            Sets the data for a single author following the same
+                            format as described above for a single sub-array.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setDateCreated()</methodname></entry>
+
+                        <entry>
+                            Sets the date on which this feed was created. Generally
+                            only applicable to Atom where it represents the date the resource
+                            described by an Atom 1.0 document was created. The expected parameter
+                            may be a UNIX timestamp or a <classname>Zend_Date</classname> object.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>getDateModified()</methodname></entry>
+
+                        <entry>
+                            Sets the date on which this feed was last modified. The expected parameter
+                            may be a UNIX timestamp or a <classname>Zend_Date</classname> object.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setLanguage()</methodname></entry>
+
+                        <entry>
+                            Sets the language of the feed. This will be omitted unless set.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>getGenerator()</methodname></entry>
+
+                        <entry>
+                            Allows the setting of a generator. The parameter should be an
+                            array containing the keys "name", "version" and "uri". If omitted
+                            a default generator will be added referencing
+                            <classname>Zend_Feed_Writer</classname>, the current Zend Framework
+                            version and the Framework's URI.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setCopyright()</methodname></entry>
+
+                        <entry>
+                            Sets a copyright notice associated with the feed.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setHubs()</methodname></entry>
+
+                        <entry>
+                            Accepts an array of Pubsubhubbub Hub Endpoints to be rendered in
+                            the feed as Atom links so that PuSH Subscribers may subscribe to
+                            your feed. Note that you must implement a Pubsubhubbub Publisher in
+                            order for real-time updates to be enabled. A Publisher may be implemented
+                            using <classname>Zend_Feed_Pubsubhubbub_Publisher</classname>.
+                        </entry>
+                    </row>
+
+                    <row>
+                        <entry><methodname>setCategories()</methodname></entry>
+
+                        <entry>
+                            Accepts an array of categories for rendering, where each element is itself
+                            an array whose possible keys include "term", "label" and "scheme". The "term"
+                            is a typically a category name suitable for inclusion in a URI. The "label"
+                            may be a human readable category name supporting special characters (it is encoded
+                            during rendering) and is a required key. The "scheme" (called the domain in RSS)
+                            is optional but must be a valid URI.
+                        </entry>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
+    </sect2>
+</sect1>

documentation/manual/de/module_specs/Zend_Markup-Parsers.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- EN-Revision: 19720 -->
+<!-- EN-Revision: 19748 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.markup.parsers">
     <title>Zend_Markup Parser</title>

documentation/manual/de/module_specs/Zend_Tool-Extending.xml

@@ -0,0 +1,878 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- EN-Revision: 19738 -->
+<!-- Reviewed: no -->
+<sect1 id="zend.tool.extending">
+    <title>Extending Zend_Tool</title>
+
+    <sect2 id="zend.tool.extending.overview">
+        <title>Overview of Zend_Tool</title>
+
+        <para>
+            <classname>Zend_Tool_Framework</classname> is a framework for exposing common
+            functionalities such as the creation of project scaffolds, code
+            generation, search index generation, and much more. Functionality may be
+            written and exposed via <acronym>PHP</acronym> classes dropped into the
+            <acronym>PHP</acronym> <property>include_path</property>, providing incredible
+            flexibility of implementation. The functionality may then be consumed by writing
+            implementation and/or protocol-specific clients -- such as console
+            clients, <acronym>XML-RPC</acronym>, <acronym>SOAP</acronym>, and much more.
+        </para>
+
+        <para>
+            <classname>Zend_Tool_Project</classname> builds on and extends the capabilities of
+            <classname>Zend_Tool_Framework</classname> to that of managing a "project". In general, a
+            "project" is a planned endeavor or an initiative. In the computer world, projects generally
+            are a collection of resources. These resources can be files, directories, databases,
+            schemas, images, styles, and more.
+        </para>
+
+    </sect2>
+
+    <sect2 id="zend.tool.extending.zend-tool-framework">
+        <title>Zend_Tool_Framework Extensions</title>
+
+        <sect3 id="zend.tool.extending.zend-tool-framework.architecture">
+            <title>Overall Architecture</title>
+
+            <para>
+                <classname>Zend_Tool_Framework</classname> provides the following:
+            </para>
+
+            <itemizedlist>
+                <listitem>
+                    <para>
+                        <emphasis>Common interfaces and abstracts</emphasis> that allow
+                        developers to create functionality and capabilities that are
+                        dispatchable by tooling clients.
+                    </para>
+                </listitem>
+
+                <listitem>
+                    <para>
+                        <emphasis>Base client functionality</emphasis> and a concrete
+                        console implementation that connect external tools and
+                        interfaces to the <classname>Zend_Tool_Framework</classname>. The Console
+                        client may be used in <acronym>CLI</acronym> environments such as unix shells and
+                        the Windows console.
+                    </para>
+                </listitem>
+
+                <listitem>
+                    <para>
+                        <emphasis>"Provider" and "Manifest" interfaces</emphasis> that
+                        can be utilized by the tooling system. "Providers" represent the
+                        functional aspect of the framework, and define the actions that
+                        tooling clients may call. "Manifests" act as metadata registries
+                        that provide additional context for the various defined
+                        providers.
+                    </para>
+                </listitem>
+
+                <listitem>
+                    <para>
+                        <emphasis>An introspective loading system</emphasis> that will
+                        scan the environment for providers and determine what is
+                        required to dispatch them.
+                    </para>
+                </listitem>
+
+                <listitem>
+                    <para>
+                        <emphasis>A standard set of system providers</emphasis> that
+                        allow the system to report what the full capabilities of the
+                        system are as well as provide useful feedback. This also
+                        includes a comprehensive "Help System".
+                    </para>
+                </listitem>
+            </itemizedlist>
+
+            <para>
+                Definitions that you should be aware of through this manual with respect
+                to <classname>Zend_Tool_Framework</classname> include:
+            </para>
+
+            <itemizedlist>
+
+                <listitem><para>
+                    <classname>Zend_Tool_Framework</classname> - The framework which exposes
+                    tooling capabilities.
+                </para></listitem>
+
+                <listitem><para>
+                    <emphasis>Tooling Client</emphasis> - A developer tool that connects
+                    to and consumes <classname>Zend_Tool_Framework</classname>.
+                </para></listitem>
+
+                <listitem><para>
+                    <emphasis>Client</emphasis> - The subsystem of
+                    <classname>Zend_Tool_Framework</classname> that exposes an interface such that
+                    tooling clients can connect, query and execute commands.
+                </para></listitem>
+
+                <listitem><para>
+                    <emphasis>Console Client / Command Line Interface /
+                    <filename>zf.php</filename></emphasis> - The tooling client for the command line.
+                </para></listitem>
+
+                <listitem><para>
+                    <emphasis>Provider</emphasis> - A subsystem and a collection of
+                    built-in functionality that the framework exports.
+                </para></listitem>
+
+                <listitem><para>
+                    <emphasis>Manifest</emphasis> - A subsystem for defining,
+                    organizing, and disseminating provider requirement data.
+                </para></listitem>
+
+                <listitem><para>
+                    <classname>Zend_Tool_Project</classname> Provider - A set of providers
+                    specifically for creating and maintaining Zend Framework-based
+                    projects.
+                </para></listitem>
+
+            </itemizedlist>
+
+        </sect3>
+
+        <sect3 id="zend.tool.extending.zend-tool-framework.cli-client">
+            <title>Understanding the CLI Client</title>
+
+            <para>
+                The <acronym>CLI</acronym>, or command line tool (internally known as the console tool),
+                is currently the primary interface for dispatching <classname>Zend_Tool</classname>
+                requests. With the <acronym>CLI</acronym> tool, developers can issue tooling requests
+                inside the "command line windows", also commonly known as a "terminal"
+                window. This environment is predominant in the *nix environment, but
+                also has a common implementation in windows with the
+                <filename>cmd.exe</filename>, console2 and also with the Cygwin project.
+            </para>
+
+            <sect4 id="zend.tool.extending.zend-tool-framework.cli-client.setup-general">
+                <title>Setting up the CLI tool</title>
+
+                <para>
+                    To issue tooling requests via the command line client, you first
+                    need to set up the client so that your system can handle the "zf"
+                    command. The command line client, for all intents and purposes, is
+                    the <filename>.sh</filename> or <filename>.bat</filename> file that is provided with
+                    your Zend Framework distribution. In trunk, it can be found here:
+                    <ulink
+                        url="http://framework.zend.com/svn/framework/standard/trunk/bin/">http://framework.zend.com/svn/framework/standard/trunk/bin/</ulink>.
+                </para>
+
+                <para>
+                    As you can see, there are 3 files in the <filename>/bin/</filename>
+                    directory: a <filename>zf.php</filename>, <filename>zf.sh</filename>, and
+                    <filename>zf.bat</filename>. The <filename>zf.sh</filename> and the
+                    <filename>zf.bat</filename> are the operating system specific client
+                    wrappers: <filename>zf.sh</filename> for the *nix environment, and
+                    <filename>zf.bat</filename> for the Win32 environment. These client wrappers are
+                    responsible for finding the proper <filename>php.exe</filename>, finding the
+                    <filename>zf.php</filename>, and passing on the client request. The
+                    <filename>zf.php</filename> is the responsible for handling understanding
+                    your environment, constructing the proper include_path, and passing
+                    what is provided on the command line to the proper library component
+                    for dispatching.
+                </para>
+
+                <para>
+                    Ultimately, you want to ensure two things to make everything work
+                    regardless of the operating system you are on:
+                </para>
+
+                <orderedlist>
+                    <listitem>
+                        <para>
+                            <filename>zf.sh/zf.bat</filename> is reachable from your system
+                            path. This is the ability to call <command>zf</command> from
+                            anywhere on your command line, regardless of what your
+                            current working directory is.
+                        </para>
+                    </listitem>
+                    <listitem>
+                        <para>
+                            <filename>ZendFramework/library</filename> is in your
+                            <property>include_path</property>.
+                        </para>
+                    </listitem>
+                </orderedlist>
+
+                <note>
+                    <para>
+                        Note: while the above are the most ideal
+                        requirements, you can simply download Zend Framework and expect it
+                        to work as <filename>./path/to/zf.php</filename> some command.
+                    </para>
+                </note>
+
+            </sect4>
+
+            <sect4 id="zend.tool.extending.zend-tool-framework.cli-client.setup-starnix">
+                <title>Setting up the CLI tool on Unix-like Systems</title>
+
+                <para>
+                    The most common setup in the *nix environment, is to copy the
+                    <filename>zf.sh</filename> and <filename>zf.php</filename> into the same directory
+                    as your <acronym>PHP</acronym> binary. This can generally be found in one of the
+                    following places:
+                </para>
+
+                <programlisting language="text"><![CDATA[
+/usr/bin
+/usr/local/bin
+/usr/local/ZendServer/bin/
+/Applications/ZendServer/bin/
+]]></programlisting>
+
+                <para>
+                    To find out the location of your <acronym>PHP</acronym> binary, you can execute 'which
+                    php' on the command line. This will return the location of the <acronym>PHP</acronym>
+                    binary you will be using to run <acronym>PHP</acronym> scripts in this environment.
+                </para>
+
+                <para>
+                    The next order of business is to ensure that Zend Framework
+                    library is set up correctly inside of the system <acronym>PHP</acronym>
+                    <property>include_path</property>. To find out where your
+                    <property>include_path</property> is located, you can execute <command>php -i</command>
+                    and look for the <property>include_path</property> variable, or more succinctly,
+                    execute <command>php -i | grep include_path</command>. Once you have found where
+                    your <property>include_path</property> is located (this will generally be
+                    something like <filename>/usr/lib/php</filename>, <filename>/usr/share/php</filename>,
+                    <filename>/usr/local/lib/php</filename>, or similar), ensure that the contents of the
+                    <filename>/library/</filename> directory are put
+                    inside your <property>include_path</property> specified directory.
+                </para>
+
+                <para>
+                    Once you have done those two things, you should be able to issue a
+                    command and get back the proper response like this:
+                </para>
+
+                <para>
+                    <inlinegraphic scale="100" align="center" valign="middle"
+                        fileref="figures/zend.tool.framework.cliversionunix.png" format="PNG" />
+                </para>
+
+                <para>
+                    If you do not see this type of output, go back and check your setup
+                    to ensure you have all of the necessary pieces in the proper place.
+                </para>
+
+                <para>
+                    There are a couple of alternative setups you might want to employ
+                    depending on your servers configuration, your level of access, or
+                    for other reasons.
+                </para>
+
+                <para>
+                    <emphasis>Alternative Setup</emphasis> involves keeping the Zend
+                    Framework download together as is, and creating a link from a <constant>PATH</constant>
+                    location to the <filename>zf.sh</filename>. What this means is you can
+                    place the contents of the ZendFramework download into a location
+                    such as <filename>/usr/local/share/ZendFramework</filename>, or more locally
+                    like <filename>/home/username/lib/ZendFramework</filename>, and creating a
+                    symbolic link to the <filename>zf.sh</filename>.
+                </para>
+
+                <para>
+                    Assuming you want to put the link inside <filename>/usr/local/bin</filename>
+                    (this could also work for placing the link inside
+                    <filename>/home/username/bin/</filename> for example) you would issue a
+                    command similar to this: </para>
+
+                <programlisting language="sh"><![CDATA[
+ln -s /usr/local/share/ZendFramework/bin/zf.sh /usr/local/bin/zf
+
+# OR (for example)
+ln -s /home/username/lib/ZendFramework/bin/zf.sh /home/username/bin/zf
+]]></programlisting>
+
+                <para>
+                    This will create a link which you should be able to access globally
+                    on the command line.
+                </para>
+
+            </sect4>
+
+            <sect4 id="zend.tool.extending.zend-tool-framework.cli-client.setup-windows">
+                <title>Setting up the CLI tool on Windows</title>
+
+                <para>
+                    The most common setup in the Windows Win32 environment, is to copy
+                    the <filename>zf.bat</filename> and <filename>zf.php</filename> into the same
+                    directory as your <acronym>PHP</acronym> binary. This can generally be found in one of
+                    the following places:
+                </para>
+
+                <programlisting language="text"><![CDATA[
+C:\PHP
+C:\Program Files\ZendServer\bin\
+C:\WAMP\PHP\bin
+]]></programlisting>
+
+                <para>
+                    You should be able to run <filename>php.exe</filename> on the command line.
+                    If you are not able to, first check the documentation that came with
+                    your <acronym>PHP</acronym> distribution, or ensure that the path to
+                    <filename>php.exe</filename> is in your
+                    Windows <constant>PATH</constant> environment variable.
+                </para>
+
+                <para>
+                    The next order of business is to ensure that Zend Framework
+                    library is set up correctly inside of the system <acronym>PHP</acronym>
+                    <property>include_path</property>. To find out where your
+                    <property>include_path</property> is located, you can type <command>php -i</command> and
+                    look for the <property>include_path</property> variable, or more succinctly
+                    execute <command>php -i | grep include_path</command> if you have Cygwin setup with
+                    grep available. Once you have found where your
+                    <property>include_path</property> is located (this will generally be
+                    something like <filename>C:\PHP\pear</filename>, <filename>C:\PHP\share</filename>,
+                    <filename>C:\Program%20Files\ZendServer\share</filename> or similar), ensure
+                    that the contents of the library/ directory are put inside your
+                    <property>include_path</property> specified directory.
+                </para>
+
+                <para>
+                    Once you have done those two things, you should be able to issue a
+                    command and get back the proper response like this:
+                </para>
+
+                <para>
+                    <inlinegraphic scale="100" align="center" valign="middle"
+                        fileref="figures/zend.tool.framework.cliversionwin32.png" format="PNG" />
+                </para>
+
+                <para>
+                    If you do not see this type of output, go back and check your setup
+                    to ensure you have all of the necessary pieces in the proper place.
+                </para>
+
+                <para>
+                    There are a couple of alternative setups you might want to employ
+                    depending on your server's configuration, your level of access, or
+                    for other reasons.
+                </para>
+
+                <para>
+                    <emphasis>Alternative Setup</emphasis> involves keeping the Zend
+                    Framework download together as is, and altering both your system
+                    <constant>PATH</constant> as well as the <filename>php.ini</filename> file.
+                    In your user's environment, make sure to add
+                    <filename>C:\Path\To\ZendFramework\bin</filename>, so that your
+                    <filename>zf.bat</filename> file is executable. Also, alter the
+                    <filename>php.ini</filename> file to ensure that
+                    <filename>C:\Path\To\ZendFramework\library</filename> is in your
+                    <property>include_path</property>.
+                </para>
+
+            </sect4>
+
+            <sect4 id="zend.tool.extending.zend-tool-framework.cli-client.setup-othernotes">
+                <title>Other Setup Considerations</title>
+
+                <para>
+                    If for some reason you do not want Zend Framework library inside
+                    your <property>include_path</property>, there is another option. There are
+                    two special environment variables that <filename>zf.php</filename> will
+                    utilize to determine the location of your Zend Framework
+                    installation.
+                </para>
+
+                <para>
+                    The first is <constant>ZEND_TOOL_INCLUDE_PATH_PREPEND</constant>, which will
+                    prepend the value of this environment variable to the system
+                    (<filename>php.ini</filename>) <property>include_path</property> before loading the
+                    client.
+                </para>
+
+                <para>
+                    Alternatively, you might want to use
+                    <constant>ZEND_TOOL_INCLUDE_PATH</constant> to completely
+                    <emphasis>replace</emphasis> the system <property>include_path</property>
+                    for one that makes sense specifically for the <command>zf</command>
+                    command line tool.
+                </para>
+            </sect4>
+
+        </sect3>
+
+        <sect3 id="zend.tool.extending.zend-tool-framework.providers-and-manifests">
+            <title>Creating Providers</title>
+
+            <para>
+                In general, a provider, on its own, is nothing more than the shell for a
+                developer to bundle up some capabilities they wish to dispatch with the
+                command line (or other) clients. It is an analogue to what a
+                "controller" is inside of your <acronym>MVC</acronym> application.
+            </para>
+
+            <sect4 id="zend.tool.extending.zend-tool-framework.providers-and-manifests.loading">
+                <title>How Zend Tool finds your Providers</title>
+
+                <para>
+                    By default Zend Tool uses the BasicLoader to find all
+                    the providers that you can run. It recursivly iterates all
+                    include path directories and opens all files that end
+                    with "Manifest.php" or "Provider.php". All classes in these
+                    files are inspected if they implement either
+                    <classname>Zend_Tool_Framework_Provider_Interface</classname>
+                    or <classname>Zend_Tool_Framework_Manifest_ProviderManifestable</classname>.
+                    Instances of the provider interface make up for the real functionality
+                    and all their public methods are accessible as provider actions.
+                    The ProviderManifestable interface however requires the implementation of a method
+                    <methodname>getProviders()</methodname> which returns an array of
+                    instantiated provider interface instances.
+                </para>
+
+                <para>
+                    The following naming rules apply on how you can access the providers
+                    that were found by the IncludePathLoader:
+                </para>
+
+                <itemizedlist>
+                    <listitem>
+                        <para>
+                            The last part of your classname split by underscore is used
+                            for the provider name, e.g. "My_Provider_Hello" leads to your
+                            provider being accessible by the name "hello".
+                        </para>
+                    </listitem>
+                    <listitem>
+                        <para>
+                            If your provider has a method <methodname>getName()</methodname>
+                            it will be used instead of the previous method to determine
+                            the name.
+                        </para>
+                    </listitem>
+                    <listitem>
+                        <para>
+                            If your provider has "Provider" as prefix, e.g. it is called
+                            <classname>My_HelloProvider</classname> it will be stripped
+                            from the name so that the provider will be called "hello".
+                        </para>
+                    </listitem>
+                </itemizedlist>
+
+                <note>
+                    <para>The IncludePathLoader does not follow symlinks, that means
+                    you cannot link provider functionality into your include paths,
+                    they have to be physically present in the include paths.</para>
+                </note>
+
+                <example id="zend.tool.extending.zend-tool-framework.providers-and-manifests.loading.example">
+                    <title>Exposing Your Providers with a Manifest</title>
+
+                    <para>
+                        You can expose your providers to Zend Tool by offering a manifest
+                        with a special filename ending with "Manifest.php".
+                        A Provider Manifest is an implementation of the
+                        <interface>Zend_Tool_Framework_Manifest_ProviderManifestable</interface>
+                        and requires the <methodname>getProviders()</methodname> method to return
+                        an array of instantiated providers. In anticipation of our first
+                        own provider <classname>My_Component_HelloProvider</classname>
+                        we will create the following manifest:
+                    </para>
+
+                    <programlisting language="php"><![CDATA[
+class My_Component_Manifest
+    implements Zend_Tool_Framework_Manifest_ProviderManifestable
+{
+    public function getProviders()
+    {
+        return array(
+            new My_Component_HelloProvider()
+        );
+    }
+}
+]]></programlisting>
+
+                </example>
+            </sect4>
+
+            <sect4 id="zend.tool.extending.zend-tool-framework.providers-and-manifests.basic">
+                <title>Basic Instructions for Creating Providers</title>
+
+                <para>
+                    As an example, if a developer wants to add the capability of showing
+                    the version of a datafile that his 3rd party component is working
+                    from, there is only one class the developer would need to implement.
+                    Assuming the component is called <classname>My_Component</classname>, he would
+                    create a class named <classname>My_Component_HelloProvider</classname> in a
+                    file named <filename>HelloProvider.php</filename> somewhere on the
+                    <property>include_path</property>. This class would implement
+                    <classname>Zend_Tool_Framework_Provider_Interface</classname>, and the body of
+                    this file would only have to look like the following:
+                </para>
+
+                <programlisting language="php"><![CDATA[
+class My_Component_HelloProvider
+    implements Zend_Tool_Framework_Provider_Interface
+{
+    public function say()
+    {
+        echo 'Hello from my provider!';
+    }
+}
+]]></programlisting>
+
+                <para>
+                    Given that code above, and assuming the developer wishes to access
+                    this functionality through the console client, the call would look
+                    like this:
+                </para>
+
+                <programlisting language="sh"><![CDATA[
+% zf say hello
+Hello from my provider!
+]]></programlisting>
+            </sect4>
+
+            <sect4 id="zend.tool.extending.zend-tool-framework.providers-and-manifests.response">
+                <title>The response object</title>
+
+                <para>
+                    As discussed in the architecture section Zend Tool allows to hook different clients for
+                    using your Zend Tool providers. To keep compliant with different clients you should
+                    use the response object to return messages from your providers instead of using
+                    <methodname>echo()</methodname> or a similiar output mechanism. Rewritting our hello
+                    provider with this knowledge it looks like:
+                </para>
+
+                <programlisting language="php"><![CDATA[
+class My_Component_HelloProvider
+    extends Zend_Tool_Framework_Provider_Abstract
+{
+    public function say()
+    {
+        $this->_registry->getResponse
+                        ->appendContent("Hello from my provider!");
+    }
+}
+]]></programlisting>
+
+                <para>
+                    As you can see one has to extend the <classname>Zend_Tool_Framework_Provider_Abstract</classname>
+                    to gain access to the Registry which holds the <classname>Zend_Tool_Framework_Client_Response</classname>
+                    instance.
+                </para>
+            </sect4>
+
+            <sect4 id="zend.tool.extending.zend-tool-framework.providers-and-manifests.advanced">
+                <title>Advanced Development Information</title>
+
+                <sect5 id="zend.tool.extending.zend-tool-framework.providers-and-manifests.advanced.variables">
+                    <title>Passing Variables to a Provider</title>
+
+                    <para>
+                        The above "Hello World" example is great for simple commands, but
+                        what about something more advanced? As your scripting and tooling
+                        needs grow, you might find that you need the ability to accept
+                        variables. Much like function signatures have parameters, your
+                        tooling requests can also accept parameters.
+                    </para>
+
+                    <para>
+                        Just as each tooling request can be isolated to a method within a
+                        class, the parameters of a tooling request can also be isolated in a
+                        very well known place. Parameters of the action methods of a
+                        provider can include the same parameters you want your client to
+                        utilize when calling that provider and action combination. For
+                        example, if you wanted to accept a name in the above example, you
+                        would probably do this in OO code:
+                    </para>
+
+                <programlisting language="php"><![CDATA[
+class My_Component_HelloProvider
+    implements Zend_Tool_Framework_Provider_Interface
+{
+    public function say($name = 'Ralph')
+    {
+        echo 'Hello' . $name . ', from my provider!';
+    }
+}
+]]></programlisting>
+
+                    <para>
+                        The above example can then be called via the command line
+                        <command>zf say hello Joe</command>. "Joe" will be supplied to the provider as
+                        a parameter of the method call. Also note, as you see that the
+                        parameter is optional, that means it is also optional on the command
+                        line, so that <command>zf say hello</command> will still work, and default
+                        to the name "Ralph".
+                    </para>
+
+                </sect5>
+
+                <sect5 id="zend.tool.extending.zend-tool-framework.providers-and-manifests.advanced.prompt">
+                    <title>Prompt the User for Input</title>
+
+                    <para>
+                        There are cases when the workflow of your provider requires
+                        to prompt the user for input. This can be done by requesting
+                        the client to ask for more the required input by calling:
+                    </para>
+
+                    <programlisting language="php"><![CDATA[
+class My_Component_HelloProvider
+    extends Zend_Tool_Framework_Provider_Abstract
+{
+    public function say($name = 'Ralph')
+    {
+        $nameResponse = $this->_registry
+                             ->getClient()
+                             ->promptInteractiveInput("Whats your name?");
+        $name = $name->getContent();
+
+        echo 'Hello' . $name . ', from my provider!';
+    }
+}
+]]></programlisting>
+
+                    <para>
+                        This command throws an exception if the current client is not
+                        able to handle interactive requests. In case of the default Console Client
+                        however you will be asked to enter the name.
+                    </para>
+                </sect5>
+
+                <sect5 id="zend.tool.extending.zend-tool-framework.providers-and-manifests.advanced.pretendable">
+                    <title>Pretending to execute a Provider Action</title>
+
+                    <para>
+                        Another interesting feature you might wish to implement is
+                        <emphasis>pretendability</emphasis>. Pretendabilty is the ability
+                        for your provider to "pretend" as if it is doing the requested
+                        action and provider combination and give the user as much
+                        information about what it <emphasis>would</emphasis> do without
+                        actually doing it. This might be an important notion when doing
+                        heavy database or filesystem modifications that the user might not
+                        otherwise want to do.
+                    </para>
+
+                    <para>
+                        Pretendability is easy to implement. There are two parts to this
+                        feature: 1) marking the provider as having the ability to "pretend",
+                        and 2) checking the request to ensure the current request was indeed
+                        asked to be "pretended". This feature is demonstrated in the code
+                        sample below.
+                    </para>
+
+                    <programlisting language="php"><![CDATA[
+class My_Component_HelloProvider
+    extends    Zend_Tool_Framework_Provider_Abstract
+    implements Zend_Tool_Framework_Provider_Pretendable
+{
+    public function say($name = 'Ralph')
+    {
+        if ($this->_registry->getRequest()->isPretend()) {
+            echo 'I would say hello to ' . $name . '.';
+        } else {
+            echo 'Hello' . $name . ', from my provider!';
+        }
+    }
+}
+]]></programlisting>
+
+                    <para>
+                        To run the provider in pretend mode just call:
+                    </para>
+
+                    <programlisting language="sh"><![CDATA[
+% zf --pretend say hello Ralph
+I would say hello Ralph.
+]]></programlisting>
+
+                </sect5>
+
+                <sect5 id="zend.tool.extending.zend-tool-framework.providers-and-manifests.advanced.verbosedebug">
+                    <title>Verbose and Debug modes</title>
+
+                    <para>
+                        You can also run your provider actions in "verbose" or "debug" modes.
+                        The semantics in regard to this actions have to be implemented by you
+                        in the context of your provider. You can access debug or verbose modes
+                        with:
+                    </para>
+
+                    <programlisting language="php"><![CDATA[
+class My_Component_HelloProvider
+    implements Zend_Tool_Framework_Provider_Interface
+{
+    public function say($name = 'Ralph')
+    {
+        if($this->_registry->getRequest()->isVerbose()) {
+            echo "Hello::say has been called\n";
+        }
+        if($this->_registry->getRequest()->isDebug()) {
+            syslog(LOG_INFO, "Hello::say has been called\n");
+        }
+    }
+}
+]]></programlisting>
+                </sect5>
+
+                <sect5 id="zend.tool.extending.zend-tool-framework.providers-and-manifests.advanced.configstorage">
+                    <title>Accessing User Config and Storage</title>
+
+                    <para>
+                        Using the Enviroment variable <property>ZF_CONFIG_FILE</property> or the
+                        .zf.ini in your home directory you can inject configuration parameters into
+                        any Zend Tool provider. Access to this configuration is available via the
+                        registry that is passed to your provider if you extend
+                        <classname>Zend_Tool_Framework_Provider_Abstract</classname>.
+                    </para>
+
+                    <programlisting language="php"><![CDATA[
+class My_Component_HelloProvider
+    extends Zend_Tool_Framework_Provider_Abstract
+{
+    public function say()
+    {
+        $username = $this->_registry->getConfig()->username;
+        if(!empty($username)) {
+            echo "Hello $username!";
+        } else {
+            echo "Hello!";
+        }
+    }
+}
+]]></programlisting>
+
+                    <para>
+                        The returned configuration is of the type
+                        <classname>Zend_Tool_Framework_Client_Config</classname> but internally the
+                        <methodname>__get()</methodname> and <methodname>__set()</methodname> magic methods
+                        proxy to a <classname>Zend_Config</classname> of the given configuration type.
+                    </para>
+
+                    <para>
+                        The storage allows to save arbitrary data for later reference. This can be useful for batch
+                        processing tasks or for re-runs of your tasks. You can access the storage in a similar way
+                        like the configuration:
+                    </para>
+
+                    <programlisting language="php"><![CDATA[
+class My_Component_HelloProvider
+    extends Zend_Tool_Framework_Provider_Abstract
+{
+    public function say()
+    {
+        $aValue = $this->_registry->getStorage()->get("myUsername");
+        echo "Hello $aValue!";
+    }
+}
+]]></programlisting>
+
+                    <para>
+                        The API of the storage is very simple:
+                    </para>
+
+                    <programlisting language="php"><![CDATA[
+class Zend_Tool_Framework_Client_Storage
+{
+    public function setAdapter($adapter);
+    public function isEnabled();
+    public function put($name, $value);
+    public function get($name, $defaultValue=null);
+    public function has($name);
+    public function remove($name);
+    public function getStreamUri($name);
+}
+]]></programlisting>
+
+                    <important>
+                        <para>
+                            When designing your providers that are config or storage aware remember to
+                            check if the required user-config or storage keys really exist for a user.
+                            You won't run into fatal errors when none of these are provided though,
+                            since empty ones are created upon request.
+                        </para>
+                    </important>
+                </sect5>
+
+            </sect4>
+
+        </sect3>
+
+    </sect2>
+
+    <sect2 id="zend.tool.extending.zend-tool-project">
+        <title>Zend_Tool_Project Extensions</title>
+
+        <para>
+            Zend_Tool_Project exposes a rich set of functionality and capabilities that make the task
+            of creating new providers, specficially those targetting project easier and more manageable.
+        </para>
+
+        <sect3 id="zend.tool.extending.zend-tool-project.architecture">
+            <title>Overall Architecture</title>
+
+            <para>
+                This same concept applies to Zend Framework projects. In Zend Framework projects, you have
+                controllers, actions, views, models, databases and so on and so forth. In terms of
+                <classname>Zend_Tool</classname>, we need a way to track these types of resources - thus
+                <classname>Zend_Tool_Project</classname>.
+            </para>
+
+            <para>
+                <classname>Zend_Tool_Project</classname> is capable of tracking project resources throughout
+                the development of a project. So, for example, if in one command you created a controller,
+                and in the next command you wish to create an action within that controller,
+                <classname>Zend_Tool_Project</classname> is gonna have to <emphasis>know</emphasis> about
+                the controller file you created so that you can (in the next action), be able to append that
+                action to it. This is what keeps our projects up to date and <emphasis>stateful</emphasis>.
+            </para>
+
+            <para>
+                Another important point to understand about projects is that typically, resources are
+                organized in a hierarchical fashion. With that in mind,
+                <classname>Zend_Tool_Project</classname> is capable of serializing the current project into
+                a internal representation that allows it to keep track of not only <emphasis>what</emphasis>
+                resources are part of a project at any given time, but also <emphasis>where</emphasis> they
+                are in relation to one another.
+            </para>
+
+        </sect3>
+
+
+        <sect3 id="zend.tool.extending.zend-tool-project.providers">
+            <title>Creating Providers</title>
+
+            <para>
+                Project specific providers are created in the same fashion as plain framework providers, with
+                one exception: project providers must extend the <code>Zend_Tool_Project_Provider_Abstract</code>.
+                This class comes with some significant functionality that helps developers load existing project,
+                obtian the profile object, and be able to search the profile, then later store any changes to the
+                current project profile.
+            </para>
+
+            <programlisting language="php"><![CDATA[
+class My_Component_HelloProvider
+    extends Zend_Tool_Project_Provider_Abstract
+{
+    public function say()
+    {
+        $profile = $this->_loadExistingProfile();
+
+        /* ... do project stuff here */
+
+        $this->_storeProfile();
+    }
+}
+]]></programlisting>
+
+        </sect3>
+
+        <!--
+        <sect3 id="zend.tool.extending.zend-tool-project.resources-and-contexts">
+            <title>Creating Resources &amp; Contexts</title>
+
+
+
+        </sect3>
+        -->
+
+    </sect2>
+</sect1>

documentation/manual/de/module_specs/Zend_Tool-Usage-CLI.xml

@@ -0,0 +1,568 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- EN-Revision: 19748 -->
+<!-- Reviewed: no -->
+<sect1 id="zend.tool.usage.cli">
+    <title>Using Zend_Tool On The Command Line</title>
+
+    <para>
+        The <acronym>CLI</acronym>, or command line tool (internally known as the console tool),
+        is currently the primary interface for dispatching <classname>Zend_Tool</classname>
+        requests. With the <acronym>CLI</acronym> tool, developers can issue tooling requests
+        inside the "command line window", also commonly known as a "terminal" window. This
+        environment is predominant in the *nix environment, but also has a common implementation
+        in windows with the <filename>cmd.exe</filename>, console2 and also with the Cygwin project.
+    </para>
+
+    <!--
+    <sect2 id="zend.tool.usage.cli.introduction">
+        <title>Introduction</title>
+    </sect2>
+    -->
+
+    <sect2 id="zend.tool.usage.cli.installation">
+        <title>Installation</title>
+
+        <sect3 id="zend.tool.usage.cli.installation.download-and-go">
+            <title>Download And Go</title>
+
+            <para>
+                First download Zend Framework.  This can be done by going to framework.zend.com
+                and downloading the latest release.  After you've downloaded the package and placed
+                it on your system.  The next step is to make the zf command available to your system.
+                The easiest way to do this, is to copy the proper files from the bin/ directory
+                of the download, and place these files within the <emphasis>same</emphasis> directory
+                as the location of the php cli binary.
+            </para>
+
+
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.installation.pear">
+            <title>Installing Via Pear</title>
+
+            <para>
+                To install via PEAR, you must use the 3rd party zfcampus.org site to retrieve the
+                latest Zend Framework PEAR package.  These packages are typically built within a day
+                of an official Zend Framework release.  The benefit of installing via the PEAR package
+                manager is that during the install process, the ZF library will end up on the
+                include_path, and the zf.php and zf scripts will end up in a place on your system
+                that will allow you to run them without any additional setup.
+            </para>
+
+            <programlisting language="text"><![CDATA[
+pear discover-channel pear.zfcampus.org
+pear install zfcampus/zf
+]]></programlisting>
+
+            <para>
+                That is it. After the initial install, you should be able to continue on by
+                running the zf command.  Go good way to check to see if it't there is to run
+                zf --help
+            </para>
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.installation.install-by-hand">
+            <title>Installing by Hand</title>
+
+            <para>
+                Installing by hand refers to the process of forcing the zf.php and Zend Framework
+                library to work together when they are placed in non-convential places, or at least,
+                in a place that your system cannot dispatch from easily (typical of programs in your
+                system PATH).
+            </para>
+
+            <para>
+                If you are on a *nix or mac system, you can also create a link from somewhere in your
+                path to the zf.sh file.  If you do this, you do not need to worry about having
+                Zend Framework's library on your include_path, as the zf.php and zf.sh files will
+                be able to access the library relative to where they are (meaning the ./bin/ files
+                are ../library/ relative to the Zend Framework library).
+            </para>
+
+            <para>
+                There are a number of other options available for setting up the zf.php and library
+                on your system.  These options revolve around setting specific environment variables.
+                These are described in the later section on "customizing the CLI environement".  The
+                environment variables for setting the zf.php include_path, ZF_INCLUDE_PATH and
+                ZF_INCLUDE_PATH_PREPEND, are the ones of most interest.
+            </para>
+
+        </sect3>
+
+    </sect2>
+
+    <sect2 id="zend.tool.usage.cli.general-purpose-commands">
+        <title>General Purpose Commands</title>
+
+        <sect3 id="zend.tool.usage.cli.general-purpose-commands.version">
+            <title>Version</title>
+
+            <para>
+                This will show the current version number of the copy of Zend Framework the zf.php tool is using.
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf show version
+]]></programlisting>
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.general-purpose-commands.built-in-help">
+            <title>Built-in Help</title>
+
+            <para>
+                The built-in help system is the primary place where you can get up-to-date information
+                on what your system is capable of doing.  The help system is dynamic in that as providers
+                are added to your system, they are automatically dispatchable, and as such, the parameters
+                required to run them will be in the help screen.  The easiest way to retrieve the help
+                screen is the following:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf --help
+]]></programlisting>
+
+            <para>
+                This will give you an overview of the various capabilities of the system.  Sometimes, there
+                are more finite commands than can be run, and to gain more information about these, you might
+                have to run a more specialized help command.  For specialized help, simply replace any of the
+                elements of the command with a "?". This will tell the help system that you want more
+                information about what commands can go in place of the question mark. For example:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf ? controller
+]]></programlisting>
+
+            <para>
+                The above means "show me all 'actions' for the provider 'controller'"; while the following:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf show ?
+]]></programlisting>
+
+            <para>
+                means "show me all providers that support the 'show' action". This works for drilling down
+                into options as well as you can see in the following examples:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf show version.? (show any specialties)
+zf show version ? (show any options)
+]]></programlisting>
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.general-purpose-commands.manifest">
+            <title>Manifest</title>
+
+            <para>
+                This will show what information is in the tooling systems manifest. This is more important
+                for provider developers than casual users of the tooling system.
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf show manifest
+]]></programlisting>
+
+        </sect3>
+
+        <!--
+        <sect3 id="zend.tool.usage.cli.general-purpose-commands.tool-configuration">
+            <title>Tool Configuration</title>
+
+            <para>Placeholder   need docs from @beberli </para>
+
+        </sect3>
+        -->
+
+    </sect2>
+
+    <sect2 id="zend.tool.usage.cli.project-specific-commands">
+        <title>Project Specific Commands</title>
+
+        <sect3 id="zend.tool.usage.cli.project-specific-commands.project">
+            <title>Project</title>
+
+            <para>
+                The project provider is the first command you might want to run. This will setup the basic
+                structure of your application. This is required before any of the other providers can
+                be executed.
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create project MyProjectName
+]]></programlisting>
+
+            <para>
+                This will create a project in a directory called ./MyProjectName.  From this point on,
+                it is important to note that any subsequent commands on the command line must be issued
+                from within the project directory you had just created.  So, after creation, changing into
+                that directory is required.
+            </para>
+
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.project-specific-commands.module">
+            <title>Project</title>
+
+            <para>
+                The module provider allows for the easy creation of a Zend Framework module.  A module
+                follows the hMVC pattern loosely.  When creating modules, it will take the same structure
+                used at the application/ level, and duplicate it inside of the chosen name for your module,
+                inside of the "modules" directory of the application/ directory without duplicating the
+                modules directory itself.  For example:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create module Blog
+]]></programlisting>
+
+            <para>
+                This will create a module named Blog at application/modules/Blog, and all of the artifacts
+                that a module will need.
+            </para>
+
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.project-specific-commands.controller">
+            <title>Controller</title>
+
+            <para>
+                The controller provider is responsible for creating (mostly) empty controllers as well
+                as their corresponding view script directories and files.  To utilize it to create
+                an 'Auth' controlller, for example, execute:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create controller Auth
+]]></programlisting>
+
+            <para>
+                This will create a controller named Auth, specifically it will create a file at
+                application/controllers/AuthController.php with the AuthController inside.
+                If you wish to create a controller for a module, use any of the following:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create controller Post 1 Blog
+zf create controller Post -m Blog
+zf create controller Post --module=Blog
+]]></programlisting>
+
+            <para>
+                Note: In the first command, 1 is the value for the "includeIndexAction" flag.
+            </para>
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.project-specific-commands.action">
+            <title>Action</title>
+
+            <para>
+                To create an action within an existing controller:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create action login Auth
+zf create action login -c Auth
+zf create action login --controller-name=Auth
+]]></programlisting>
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.project-specific-commands.view">
+            <title>View</title>
+
+            <para>
+                To create a view outside of the normal controller/action creation, you would use
+                one of the following:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create view Auth my-script-name
+zf create view -c Auth -a my-script-name
+            ]]></programlisting>
+
+            <para>
+                This will create a view script in the controller folder of Auth.
+            </para>
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.project-specific-commands.model">
+            <title>Model</title>
+
+            <para>
+                The model provider is only responsible for creating the proper model files,
+                with the proper name inside the application folder. For example
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create model User
+]]></programlisting>
+
+            <para>
+                If you wish to create a model within a specific module:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create model Post -m Blog
+]]></programlisting>
+
+            <para>
+                The above will create a 'Post' model inside of the 'Blog' module.
+            </para>
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.project-specific-commands.form">
+            <title>Form</title>
+
+            <para>
+                The form provider is only responsible for creating the proper form file and
+                init() method, with the proper name inside the application folder. For example:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create form Auth
+]]></programlisting>
+
+            <para>
+                If you wish to create a model within a specific module:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create form Comment -m Blog
+]]></programlisting>
+
+            <para>
+                The above will create a 'Comment' form inside of the 'Blog' module.
+            </para>
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.project-specific-commands.database-adapter">
+            <title>DbAdapter</title>
+
+            <para>
+                To configure a DbAdapter, you will need to provide the information as a url
+                encoded string. This string needs to be in quotes on the command line.
+            </para>
+
+            <para>
+
+                For example, to enter the following information:
+
+                <itemizedlist>
+                    <listitem>
+                        <para>adapter: Pdo_Mysql</para>
+                    </listitem>
+                    <listitem>
+                        <para>username: test</para>
+                    </listitem>
+                    <listitem>
+                        <para>password: test</para>
+                    </listitem>
+                    <listitem>
+                        <para>dbname: test </para>
+                    </listitem>
+                </itemizedlist>
+
+                The following will have to be run on the command line:
+            </para>
+
+
+            <programlisting language="text"><![CDATA[
+zf configure dbadapter "adapter=Pdo_Mysql&username=test&password=test&dbname=test"
+]]></programlisting>
+
+            <para>
+                This assumes you wish to store this information inside of the
+                'production' space of the application configuration file. The following will
+                demonstrate an sqlite configuration, in the 'development' section of the
+                application config file.
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf configure dbadapter "adapter=Pdo_Sqlite&dbname=../data/test.db" development
+zf configure dbadapter "adapter=Pdo_Sqlite&dbname=../data/test.db" -s development
+]]></programlisting>
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.project-specific-commands.db-table">
+            <title>DbTable</title>
+
+            <para>
+                The DbTable provider is responsible for creating Zend_Db_Table
+                model/data access files for your application to consume, with the proper
+                class name, and in the proper location in the application. The two
+                important pieces of information are the <emphasis>DbTable name</emphasis>,
+                and the <emphasis>actual database table name</emphasis>. For example:
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create dbtable User user
+zf create dbtable User -a user
+
+// also accepts a force option to overwrite existing files
+zf create dbtable User user -f
+zf create dbtable User user --force-override
+]]></programlisting>
+
+            <para>
+                The DbTable provider is also capable of creating the proper files by
+                scanning the database configured with the above DbAdapter provider.
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf create dbtable.from-database
+]]></programlisting>
+
+            <para>
+                When executing the above, it might make sense to use the pretend / "-p"
+                flag first so that you can see what would be done, and what tables can
+                be found in the database.
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf -p create dbtable.from-database
+]]></programlisting>
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.project-specific-commands.layout">
+            <title>Layout</title>
+
+            <para>
+                Currently, the only supported action for layouts is simply to enable them
+                will setup the proper keys in the application.ini file for the application
+                resource to work, and create the proper directories and layout.phtml file.
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf enable layout
+]]></programlisting>
+
+        </sect3>
+
+    </sect2>
+
+    <sect2 id="zend.tool.usage.cli.environment-customization">
+        <title>Environment Customization</title>
+
+        <sect3 id="zend.tool.usage.cli.environment-customization.storage-directory">
+            <title>The Storage Directory</title>
+
+            <para>
+                The storage directory is important so that providers may have a place to find
+                custom user generated logic that might change the way they behave. One example
+                can be found below is the placement of a custom project profile file.
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf --setup storage-directory
+]]></programlisting>
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.environment-customization.configuration-file">
+            <title>The Configuration File</title>
+
+            <para>
+                This will create the proper zf.ini file. This <emphasis>should</emphasis>
+                be run after <code>zf --setup storage-directory</code>. If it is not, it will
+                be located inside the users home directory. If it is, it will be located inside
+                the users storage directory.
+            </para>
+
+            <programlisting language="text"><![CDATA[
+zf --setup config-file
+]]></programlisting>
+
+        </sect3>
+
+        <sect3 id="zend.tool.usage.cli.environment-customization.environment-locations">
+            <title>Environment Locations</title>
+
+            <para>
+                These should be set if you wish to override the default places where zf will
+                attempt to read their values.
+            </para>
+
+            <itemizedlist>
+                <listitem>
+                    <para>ZF_HOME</para>
+                    <itemizedlist>
+                        <listitem><para>the directory this tool will look for a home directory</para></listitem>
+                        <listitem><para>directory must exist</para></listitem>
+                        <listitem>
+                            <para>search order:</para>
+                            <itemizedlist>
+                                <listitem><para>ZF_HOME environment variable</para></listitem>
+                                <listitem><para>HOME environment variable</para></listitem>
+                                <listitem><para>then HOMEPATH environment variable</para></listitem>
+                            </itemizedlist>
+                        </listitem>
+                    </itemizedlist>
+                </listitem>
+                <listitem>
+                    <para>ZF_STORAGE_DIRECTORY</para>
+                    <itemizedlist>
+                        <listitem><para>where this tool will look for a storage directory</para></listitem>
+                        <listitem><para>directory must exist</para></listitem>
+                        <listitem>
+                            <para>search order:</para>
+                            <itemizedlist>
+                                <listitem><para>ZF_STORAGE_DIRECTORY environment variable</para></listitem>
+                                <listitem><para>$homeDirectory/.zf/ directory</para></listitem>
+                            </itemizedlist>
+                        </listitem>
+                    </itemizedlist>
+                </listitem>
+                <listitem>
+                    <para>ZF_CONFIG_FILE</para>
+                    <itemizedlist>
+                        <listitem><para>where this tool will look for a configuration file</para></listitem>
+                        <listitem>
+                            <para>search order:</para>
+                            <itemizedlist>
+                                <listitem><para>ZF_CONFIG_FILE environment variable</para></listitem>
+                                <listitem><para>$homeDirectory/.zf.ini file if it exists</para></listitem>
+                                <listitem><para>$storageDirectory/zf.ini file if it exists</para></listitem>
+                            </itemizedlist>
+                        </listitem>
+                    </itemizedlist>
+                </listitem>
+                <listitem>
+                    <para>ZF_INCLUDE_PATH</para>
+                    <itemizedlist>
+                        <listitem><para>set the include_path for this tool to use this value</para></listitem>
+                        <listitem>
+                            <para>original behavior:</para>
+                            <itemizedlist>
+                                <listitem><para>use php's include_path to find ZF</para></listitem>
+                                <listitem><para>use the ZF_INCLUDE_PATH environment variable</para></listitem>
+                                <listitem><para>use the path ../library (relative to zf.php) to find ZF</para></listitem>
+                            </itemizedlist>
+                        </listitem>
+                    </itemizedlist>
+                </listitem>
+                <listitem>
+                    <para>ZF_INCLUDE_PATH_PREPEND</para>
+                    <itemizedlist>
+                        <listitem><para>prepend the current php.ini include_path with this value</para></listitem>
+                    </itemizedlist>
+                </listitem>
+            </itemizedlist>
+
+        </sect3>
+
+    </sect2>
+
+</sect1>