Added some french doc related to 1.8 release

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

documentation/manual/fr/module_specs/Zend_CodeGenerator-Examples.xml

@@ -0,0 +1,407 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.codegenerator.examples">
+    <title>Exemples Zend_CodeGenerator</title>
+
+    <example id="zend.codegenerator.examples.class">
+        <title>Génération de classes PHP</title>
+
+        <para>
+            L'exemple suivant génère le code d'une classe avec son bloc de commentaires PHPDoc.
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$foo      = new Zend_CodeGenerator_Php_Class();
+$docblock = new Zend_CodeGenerator_Php_Docblock(array(
+    'shortDescription' => 'Sample generated class',
+    'longDescription'  => 'This is a class generated with Zend_CodeGenerator.',
+    'tags'             => array(
+        array(
+            'name'        => 'version',
+            'description' => '$Rev:$',
+        ),
+        array(
+            'name'        => 'license',
+            'description' => 'New BSD',
+        ),
+    ),
+));
+$foo->setName('Foo')
+    ->setDocblock($docblock);
+echo $foo->generate();
+]]></programlisting>
+
+        <para>
+            Le résultat est:
+        </para>
+
+            <programlisting role="php"><![CDATA[
+/**
+ * Sample generated class
+ *
+ * This is a class generated with Zend_CodeGenerator.
+ *
+ * @version $Rev:$
+ * @license New BSD
+ *
+ */
+class Foo
+{
+
+}
+]]></programlisting>
+    </example>
+
+    <example id="zend.codegenerator.examples.class-properties">
+        <title>Generer des classes PHP avec des attributs de classe</title>
+
+        <para>
+            Suivant l'exemple précédant, nous ajoutons maintenant des attributs à la classe.
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$foo      = new Zend_CodeGenerator_Php_Class();
+$docblock = new Zend_CodeGenerator_Php_Docblock(array(
+    'shortDescription' => 'Sample generated class',
+    'longDescription'  => 'This is a class generated with Zend_CodeGenerator.',
+    'tags'             => array(
+        array(
+            'name'        => 'version',
+            'description' => '$Rev:$',
+        ),
+        array(
+            'name'        => 'license',
+            'description' => 'New BSD',
+        ),
+    ),
+));
+$foo->setName('Foo')
+    ->setDocblock($docblock)
+    ->setProperties(array(
+        array(
+            'name'         => '_bar',
+            'visibility'   => 'protected',
+            'defaultValue' => 'baz',
+        ),
+        array(
+            'name'         => 'baz',
+            'visibility'   => 'public',
+            'defaultValue' => 'bat',
+        ),
+        array(
+            'name'         => 'bat',
+            'const'        => true,
+            'defaultValue' => 'foobarbazbat',
+        ),
+    ));
+echo $foo->generate();
+]]></programlisting>
+
+        <para>
+            Le résultat sera:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+/**
+ * Sample generated class
+ *
+ * This is a class generated with Zend_CodeGenerator.
+ *
+ * @version $Rev:$
+ * @license New BSD
+ *
+ */
+class Foo
+{
+
+    protected $_bar = 'baz';
+
+    public $baz = 'bat';
+
+    const bat = 'foobarbazbat';
+
+}
+]]></programlisting>
+    </example>
+
+    <example id="zend.codegenerator.examples.class-methods">
+        <title>Générer des classes PHP avec des méthodes</title>
+
+        <para>
+            <classname>Zend_CodeGenerator_Php_Class</classname> vous permet d'attacher des méthodes
+            à vos classes générées. L'attachement se fait soit par des tableaux, soit directement des
+            objets <classname>Zend_CodeGenerator_Php_Method</classname>.
+        </para>
+
+            <programlisting role="php"><![CDATA[
+$foo      = new Zend_CodeGenerator_Php_Class();
+$docblock = new Zend_CodeGenerator_Php_Docblock(array(
+    'shortDescription' => 'Sample generated class',
+    'longDescription'  => 'This is a class generated with Zend_CodeGenerator.',
+    'tags'             => array(
+        array(
+            'name'        => 'version',
+            'description' => '$Rev:$',
+        ),
+        array(
+            'name'        => 'license',
+            'description' => 'New BSD',
+        ),
+    ),
+));
+$foo->setName('Foo')
+    ->setDocblock($docblock)
+    ->setProperties(array(
+        array(
+            'name'         => '_bar',
+            'visibility'   => 'protected',
+            'defaultValue' => 'baz',
+        ),
+        array(
+            'name'         => 'baz',
+            'visibility'   => 'public',
+            'defaultValue' => 'bat',
+        ),
+        array(
+            'name'         => 'bat',
+            'const'        => true,
+            'defaultValue' => 'foobarbazbat',
+        ),
+    ))
+    ->setMethods(array(
+        // Method passed as array
+        array(
+            'name'       => 'setBar',
+            'parameters' => array(
+                array('name' => 'bar'),
+            ),
+            'body'       => '$this->_bar = $bar;' . "\n" . 'return $this;',
+            'docblock'   => new Zend_CodeGenerator_Php_Docblock(array(
+                'shortDescription' => 'Set the bar property',
+                'tags'             => array(
+                    new Zend_CodeGenerator_Php_Docblock_Tag_Param(array(
+                        'paramName' => 'bar',
+                        'datatype'  => 'string'
+                    )),
+                    new Zend_CodeGenerator_Php_Docblock_Tag_Return(array(
+                        'datatype'  => 'string',
+                    )),
+                ),
+            )),
+        ),
+        // Method passed as concrete instance
+        new Zend_CodeGenerator_Php_Method(array(
+            'name' => 'getBar',
+            'body'       => 'return $this->_bar;',
+            'docblock'   => new Zend_CodeGenerator_Php_Docblock(array(
+                'shortDescription' => 'Retrieve the bar property',
+                'tags'             => array(
+                    new Zend_CodeGenerator_Php_Docblock_Tag_Return(array(
+                        'datatype'  => 'string|null',
+                    )),
+                ),
+            )),
+        )),
+    ));
+
+echo $foo->generate();
+]]></programlisting>
+
+        <para>
+            Le résultat sera:
+        </para>
+
+            <programlisting role="php"><![CDATA[
+/**
+ * Sample generated class
+ *
+ * This is a class generated with Zend_CodeGenerator.
+ *
+ * @version $Rev:$
+ * @license New BSD
+ */
+class Foo
+{
+
+    protected $_bar = 'baz';
+
+    public $baz = 'bat';
+
+    const bat = 'foobarbazbat';
+
+    /**
+     * Set the bar property
+     *
+     * @param string bar
+     * @return string
+     */
+    public function setBar($bar)
+    {
+        $this->_bar = $bar;
+        return $this;
+    }
+
+    /**
+     * Retrieve the bar property
+     *
+     * @return string|null
+     */
+    public function getBar()
+    {
+        return $this->_bar;
+    }
+
+}
+]]></programlisting>
+    </example>
+
+    <example id="zend.codegenerator.examples.file">
+        <title>Générer des fichiers PHP</title>
+
+        <para>
+            <classname>Zend_CodeGenerator_Php_File</classname> sert à générer le contenu de fichiers PHP.
+            Il est possible d'insérer du code de classes, ou du code PHP banal. Si vous attachez des classes,
+            vous pouvez les passer sous forme de tableaux ou directement d'objets
+            <classname>Zend_CodeGenerator_Php_Class</classname>.
+        </para>
+
+        <para>
+            Dans l'exemple suivant, nous supposonsque vous avez défini
+            <code>$foo</code> comme étant le code d'une des classes des exemples précédants.
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$file = new Zend_CodeGenerator_Php_File(array(
+    'classes'  => array($foo);
+    'docblock' => new Zend_CodeGenerator_Php_Docblock(array(
+        'shortDescription' => 'Foo class file',
+        'tags'             => array(
+            array(
+                'name'        => 'license',
+                'description' => 'New BSD',
+            ),
+        ),
+    )),
+    'body'     => 'define(\'APPLICATION_ENV\', \'testing\');',
+));
+]]></programlisting>
+
+        <para>
+            L'appel à <code>generate()</code> va générer le code, mais pas l'écrire dans un fichier.
+            Pour ce faire, il faudra d'abord capturer le contenu:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$code = $file->generate();
+file_put_contents('Foo.php', $code);
+]]></programlisting>
+
+        <para>
+            Le résultat sera:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+<?php
+/**
+ * Foo class file
+ *
+ * @license New BSD
+ */
+
+/**
+ * Sample generated class
+ *
+ * This is a class generated with Zend_CodeGenerator.
+ *
+ * @version $Rev:$
+ * @license New BSD
+ */
+class Foo
+{
+
+    protected $_bar = 'baz';
+
+    public $baz = 'bat';
+
+    const bat = 'foobarbazbat';
+
+    /**
+     * Set the bar property
+     *
+     * @param string bar
+     * @return string
+     */
+    public function setBar($bar)
+    {
+        $this->_bar = $bar;
+        return $this;
+    }
+
+    /**
+     * Retrieve the bar property
+     *
+     * @return string|null
+     */
+    public function getBar()
+    {
+        return $this->_bar;
+    }
+
+}
+
+define('APPLICATION_ENV', 'testing');
+]]></programlisting>
+    </example>
+
+    <example id="zend.codegenerator.examples.reflection-file">
+        <title>Ajouter du code à un fichier PHP existant en utilisant la réflexion</title>
+
+        <para>
+            Vous pouvez ajouter du code à n'importe quel fichier PHP existant à condition
+            d'utiliser la réflexion sur celui-ci afin de l'analyser. La méthode
+            <code>fromReflectedFileName()</code> va vous y aider
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$generator = Zend_CodeGenerator_Php_File::fromReflectedFileName($path);
+$body = $generator->getBody();
+$body .= "\n\$foo->bar();";
+file_put_contents($path, $generator->generate());
+]]></programlisting>
+    </example>
+
+    <example id="zend.codegenerator.examples.reflection-class">
+        <title>Ajouter du code à une classe PHP existante en utilisant la réflexion</title>
+        <para>
+            Vous pouvez aussi ajouter du code à une classe PHP existante. Utilisez
+            <code>fromReflection()</code> pour transformer la classe en objet Reflection.
+            Ajoutez ensuite des méthodes, des attributs, puis régénérez le code de la classe modifiée:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$generator = Zend_CodeGenerator_Php_Class::fromReflection(
+    new Zend_Reflection_Class($class)
+);
+$generator->setMethod(array(
+    'name'       => 'setBaz',
+    'parameters' => array(
+        array('name' => 'baz'),
+    ),
+    'body'       => '$this->_baz = $baz;' . "\n" . 'return $this;',
+    'docblock'   => new Zend_CodeGenerator_Php_Docblock(array(
+        'shortDescription' => 'Set the baz property',
+        'tags'             => array(
+            new Zend_CodeGenerator_Php_Docblock_Tag_Param(array(
+                'paramName' => 'baz',
+                'datatype'  => 'string'
+            )),
+            new Zend_CodeGenerator_Php_Docblock_Tag_Return(array(
+                'datatype'  => 'string',
+            )),
+        ),
+    )),
+));
+$code = $generator->generate();
+]]></programlisting>
+    </example>
+</sect1>

documentation/manual/fr/module_specs/Zend_CodeGenerator-Introduction.xml

@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.codegenerator.introduction">
+    <title>Introduction</title>
+
+    <para>
+        <classname>Zend_CodeGenerator</classname> est un outils permettant de générer du code PHP
+        en utilisant une interface orientée objet. Il peut générer ou mettre à jour du code.
+        Il est aussi possible d'étendre ces classes afin de changer le langage de référence
+        pour générer du Javascript, des hôtes virtuels Apache ..., par exemple.
+    </para>
+
+    <sect2 id="zend.codegenerator.introduction.theory">
+        <title>Théorie</title>
+
+        <para>
+            Dans la plupart des cas, vous crérez une instance du générateur de code, et vous le configurez.
+            Pour afficher le code généré, un simple echo suffira, ou l'appel à sa méthode <code>generate()</code>.
+        </para>
+
+        <programlisting role="php"><![CDATA[
+// Passage de configuration au constructor:
+$file = new Zend_CodeGenerator_Php_File(array(
+    'classes' => array(
+        new Zend_CodeGenerator_Php_Class(array(
+            'name'    => 'World',
+            'methods' => array(
+                new Zend_CodeGenerator_Php_Method(array(
+                    'name' => 'hello',
+                    'body' => 'echo \'Hello world!\';',
+                )),
+            ),
+        )),
+    )
+));
+
+// Configuration après instanciation
+$method = new Zend_CodeGenerator_Php_Method();
+$method->setName('hello')
+       ->setBody('echo \'Hello world!\';');
+
+$class = new Zend_CodeGenerator_Php_Class();
+$class->setName('World')
+      ->setMethod($method);
+
+$file = new Zend_CodeGenerator_Php_File();
+$file->setClass($class);
+
+// Rendu du fichier généré:
+echo $file;
+
+// 2criture du fichier généré:
+file_put_contents('World.php', $file->generate());
+]]></programlisting>
+
+        <para>
+            Les 2 exemples ci-dessus vont rendre le même résultat:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+<?php
+
+class World
+{
+
+    public function hello()
+    {
+        echo 'Hello world!';
+    }
+
+}
+]]></programlisting>
+
+        <para>
+            Il est aussi possible de mettre à jour un code existant, par exemple, ajouter une méthode
+            à une classe. Dans ce cas, vous devez inspecter le code existant en utilisant la réflexion,
+            puis ajouter une nouvelle méthode.
+            <classname>Zend_CodeGenerator</classname> rend ceci très simple en utilisant
+            <link linkend="zend.reflection">Zend_Reflection</link>.
+        </para>
+
+        <para>
+            Par exemple, imaginons que nous avons sauvegardé le code de l'exemple ci-dessus
+            dans un fichier "World.php" que nous avons alors inclus. Nous pourrions dès lors agir comme
+            suit:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$class = Zend_CodeGenerator_Php_Class::fromReflection(
+    new Zend_Reflection_Class('World')
+);
+
+$method = new Zend_CodeGenerator_Php_Method();
+$method->setName('mrMcFeeley')
+       ->setBody('echo \'Hello, Mr. McFeeley!\';');
+$class->setMethod($method);
+
+$file = new Zend_CodeGenerator_Php_File();
+$file->setClass($class);
+
+// Rendu du code généré
+echo $file;
+
+// Ou encore sauvegarde par dessus l'ancien fichier
+file_put_contents('World.php', $file->generate());
+]]></programlisting>
+
+        <para>
+            La nouvelle classe ressemblera à cà:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+<?php
+
+class World
+{
+
+    public function hello()
+    {
+        echo 'Hello world!';
+    }
+
+    public function mrMcFeeley()
+    {
+        echo 'Hellow Mr. McFeeley!';
+    }
+
+}
+]]></programlisting>
+    </sect2>
+</sect1>

documentation/manual/fr/module_specs/Zend_CodeGenerator-Reference.xml

@@ -0,0 +1,489 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.codegenerator.reference">
+    <title>Zend_CodeGenerator Réference</title>
+
+    <sect2 id="zend.codegenerator.reference.abstracts">
+        <title>Classes abstraites et interfaces</title>
+
+        <sect3 id="zend.codegenerator.reference.abstracts.abstract">
+            <title>Zend_CodeGenerator_Abstract</title>
+
+            <para>
+                La classe de base de CodeGenerator dont toutes les classes héritent.
+                Elle propose l'API suivante:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+abstract class Zend_CodeGenerator_Abstract
+{
+    final public function __construct(Array $options = array())
+    public function setOptions(Array $options)
+    public function setSourceContent($sourceContent)
+    public function getSourceContent()
+    protected function _init()
+    protected function _prepare()
+    abstract public function generate();
+    final public function __toString()
+}
+]]></programlisting>
+
+            <para>
+                Le constructeur appelle <code>_init()</code> (restée vide, à
+                écrire dans les classes concrêtes),
+                puis passe le paramètre <code>$options</code> à
+                <code>setOptions()</code>, et enfin appelle
+                <code>_prepare()</code> (encore une fois, vide, à écrire dans les
+                classes concrêtes).
+            </para>
+
+            <para>
+                Comme partout dans le Zend Framework, <code>setOptions()</code>
+                compare les clés du tableau passé comme paramètre à des setters
+                de la classe, et passe donc la valeur à la bonne méhode si trouvée.
+            </para>
+
+            <para>
+                <code>__toString()</code> est marquée final, et proxie vers
+                <code>generate()</code>.
+            </para>
+
+            <para>
+                <code>setSourceContent()</code> et
+                <code>getSourceContent()</code> permettent soit de définir le contenu par défaut
+                soit de remplacer ce contenu par la tâche de génération.
+            </para>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.abstracts.php-abstract">
+            <title>Zend_CodeGenerator_Php_Abstract</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Abstract</classname> étend
+                <classname>Zend_CodeGenerator_Abstract</classname> et ajoute des méthodes
+                permettant de savoir si le contenu a changé et aussi le nombre d'indentation
+                à utiliser avant chaque ligne de code à générer. L'API est la suivante:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+abstract class Zend_CodeGenerator_Php_Abstract
+    extends Zend_CodeGenerator_Abstract
+{
+    public function setSourceDirty($isSourceDirty = true)
+    public function isSourceDirty()
+    public function setIndentation($indentation)
+    public function getIndentation()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.abstracts.php-member-abstract">
+            <title>Zend_CodeGenerator_Php_Member_Abstract</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Member_Abstract</classname> est une classe de base
+                pour générer des propriétés ou des méthodes de classe, et propose des accesseurs et des
+                mutateurs pour créer la visibilité, l'abstraction, la staticité ou la finalité.
+                L'API est la suivante:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+abstract class Zend_CodeGenerator_Php_Member_Abstract
+    extends Zend_CodeGenerator_Php_Abstract
+{
+    public function setAbstract($isAbstract)
+    public function isAbstract()
+    public function setStatic($isStatic)
+    public function isStatic()
+    public function setVisibility($visibility)
+    public function getVisibility()
+    public function setName($name)
+    public function getName()
+}
+]]></programlisting>
+        </sect3>
+    </sect2>
+
+    <sect2 id="zend.codegenerator.reference.concrete">
+        <title>Classes CodeGenerator concrêtes</title>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-body">
+            <title>Zend_CodeGenerator_Php_Body</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Body</classname> est utilisée pour générer
+                du code PHP procédural à inclure dans un fichier. Vous passez donc simplement
+                du contenu à cet objet, qui vous le resortira une fois son
+                <code>generate()</code> appelé.
+            </para>
+
+            <para>
+                L'API de cette classe est comme suit:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Body extends Zend_CodeGenerator_Php_Abstract
+{
+    public function setContent($content)
+    public function getContent()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-class">
+            <title>Zend_CodeGenerator_Php_Class</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Class</classname> est utilisée pour
+                générer du code de classes PHP. Les fonctions de bases génèrent la classe
+                elle-même, ainsi que ses commentaires PHPDoc. Vous pouvez bien sûr
+                spécifier la classe comme abstraite, finale, ou encore lui rajouter des
+                constantes/attributs/méthodes sous forme d'autres objets décrits eux
+                aussi dans ce chapitre.
+            </para>
+
+            <para>
+                Voici l'API:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Class extends Zend_CodeGenerator_Php_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Class $reflectionClass
+    )
+    public function setDocblock(Zend_CodeGenerator_Php_Docblock $docblock)
+    public function getDocblock()
+    public function setName($name)
+    public function getName()
+    public function setAbstract($isAbstract)
+    public function isAbstract()
+    public function setExtendedClass($extendedClass)
+    public function getExtendedClass()
+    public function setImplementedInterfaces(Array $implementedInterfaces)
+    public function getImplementedInterfaces()
+    public function setProperties(Array $properties)
+    public function setProperty($property)
+    public function getProperties()
+    public function getProperty($propertyName)
+    public function setMethods(Array $methods)
+    public function setMethod($method)
+    public function getMethods()
+    public function getMethod($methodName)
+    public function hasMethod($methodName)
+    public function isSourceDirty()
+    public function generate()
+}
+]]></programlisting>
+
+            <para>
+                La méthode <code>setProperty()</code> accepte soit un tableau qui peut être utilisé pour
+                générer une instance de <classname>Zend_CodeGenerator_Php_Property</classname>,
+                soit directement une instance de <classname>Zend_CodeGenerator_Php_Property</classname>.
+                <code>setMethod()</code> se manipule de la même manière, et utilise une instance de
+                <classname>Zend_CodeGenerator_Php_Method</classname>.
+            </para>
+
+            <para>
+                A noter que <code>setDocBlock()</code> attend une instance de
+                <classname>Zend_CodeGenerator_Php_DocBlock</classname>.
+            </para>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-docblock">
+            <title>Zend_CodeGenerator_Php_Docblock</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Docblock</classname> est utilisée pour générer du code
+                PHPDoc arbitraire, y compris les commentaires de description longs ou courts.
+            </para>
+
+            <para>
+                Les tags annotation doivent être spécifiés via <code>setTag()</code> ou <code>setTags()</code>
+                qui prennent en paramètre un objet <classname>Zend_CodeGenerator_Php_Docblock_Tag</classname>
+                ou un tableau qui permettra sa construction.
+            </para>
+
+            <para>
+                Voici l'API:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Docblock extends Zend_CodeGenerator_Php_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Docblock $reflectionDocblock
+    )
+    public function setShortDescription($shortDescription)
+    public function getShortDescription()
+    public function setLongDescription($longDescription)
+    public function getLongDescription()
+    public function setTags(Array $tags)
+    public function setTag($tag)
+    public function getTags()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-docblock-tag">
+            <title>Zend_CodeGenerator_Php_Docblock_Tag</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Docblock_Tag</classname> est utilisée pour créer
+                des tags d'annotation PHPdoc. Les tags doivent posséder un nom (la partie qui suit 
+                immédiatement le '@') et une description (ce qui suit le tag).
+            </para>
+
+            <para>
+                Voici l'API:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Docblock_Tag
+    extends Zend_CodeGenerator_Php_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Docblock_Tag $reflectionTag
+    )
+    public function setName($name)
+    public function getName()
+    public function setDescription($description)
+    public function getDescription()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-docblock-tag-param">
+            <title>Zend_CodeGenerator_Php_DocBlock_Tag_Param</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_DocBlock_Tag_Param</classname> est une version
+                spéciale de <classname>Zend_CodeGenerator_Php_DocBlock_Tag</classname>, et
+                permet de représenter un paramètre d'une méthode. Le nom du tag est donc connu,
+                mais des informations additionnelles sont requises : le nom du paramètre
+                et le type de données qu'il représente.
+            </para>
+
+            <para>
+                L'API de cette classe est la suivante:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Docblock_Tag_Param
+    extends Zend_CodeGenerator_Php_Docblock_Tag
+{
+    public static function fromReflection(
+        Zend_Reflection_Docblock_Tag $reflectionTagParam
+    )
+    public function setDatatype($datatype)
+    public function getDatatype()
+    public function setParamName($paramName)
+    public function getParamName()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-docblock-tag-return">
+            <title>Zend_CodeGenerator_Php_DocBlock_Tag_Return</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Docblock_Tab_Return</classname> est une variante
+                qui permet de modéliser la valeur de retour d'une méthode. Dans ce cas, le nom du tag
+                est connu ('return') mais pas le type de retour.
+            </para>
+
+            <para>
+                Voici l'API:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Docblock_Tag_Param
+    extends Zend_CodeGenerator_Php_Docblock_Tag
+{
+    public static function fromReflection(
+        Zend_Reflection_Docblock_Tag $reflectionTagReturn
+    )
+    public function setDatatype($datatype)
+    public function getDatatype()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-file">
+            <title>Zend_CodeGenerator_Php_File</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_File</classname> est utilisée pour générer
+                le contenu complet d'un fichier PHP. Le fichier peut contenir des classes, du code
+                PHP ou encore des commentaires PHPDoc.
+            </para>
+
+            <para>
+                Pour ajouter des classes, vous devrez soit passer un tableau d'informations à passer au constructeur
+                de <classname>Zend_CodeGenerator_Php_Class</classname>, soit un objet de cette dernière classe directement.
+                Idem concernant les commentaires PHPDoc et la classe <classname>Zend_CodeGenerator_Php_Docblock</classname>
+            </para>
+
+            <para>
+                Voici l'API de la classe:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_File extends Zend_CodeGenerator_Php_Abstract
+{
+    public static function fromReflectedFilePath(
+        $filePath,
+        $usePreviousCodeGeneratorIfItExists = true,
+        $includeIfNotAlreadyIncluded = true)
+    public static function fromReflection(Zend_Reflection_File $reflectionFile)
+    public function setDocblock(Zend_CodeGenerator_Php_Docblock $docblock)
+    public function getDocblock()
+    public function setRequiredFiles($requiredFiles)
+    public function getRequiredFiles()
+    public function setClasses(Array $classes)
+    public function getClass($name = null)
+    public function setClass($class)
+    public function setFilename($filename)
+    public function getFilename()
+    public function getClasses()
+    public function setBody($body)
+    public function getBody()
+    public function isSourceDirty()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-member-container">
+            <title>Zend_CodeGenerator_Php_Member_Container</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Member_Container</classname> est utilisée en interne par
+                <classname>Zend_CodeGenerator_Php_Class</classname> pour garder une trace des attributs et
+                des méthodes de classe. Ceux-ci sont indéxés par nom.
+            </para>
+
+            <para>
+                Voici l'API de cette classe:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Member_Container extends ArrayObject
+{
+    public function __construct($type = self::TYPE_PROPERTY)
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-method">
+            <title>Zend_CodeGenerator_Php_Method</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Method</classname> est utilisée pour décrire
+                une méthode d'une classe, et va générer son code, et ses éventuels commentaires
+                PHPDoc. La visibilité et le statut (abstraite, finale, statique) peuvent être
+                spécifiées par la classe parente
+                <classname>Zend_CodeGenerator_Php_Member_Abstract</classname>. Enfin,
+                il est aussi possible de spécifier les paramètres de la méthodes, et sa valeur de
+                retour.
+            </para>
+
+            <para>
+                Les paramètres peuvent être indiqués via <code>setParameter()</code> ou
+                <code>setParameters()</code> qui acceptent soit des tableaux décrivant les paramètres
+                à passer au constructeur de<classname>Zend_CodeGenerator_Php_Parameter</classname>, soit
+                des objets de cette dernière classe.
+            </para>
+
+            <para>
+                L'API de cette classe est la suivante:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Method
+    extends Zend_CodeGenerator_Php_Member_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Method $reflectionMethod
+    )
+    public function setDocblock(Zend_CodeGenerator_Php_Docblock $docblock)
+    public function getDocblock()
+    public function setFinal($isFinal)
+    public function setParameters(Array $parameters)
+    public function setParameter($parameter)
+    public function getParameters()
+    public function setBody($body)
+    public function getBody()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-parameter">
+            <title>Zend_CodeGenerator_Php_Parameter</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Parameter</classname> est utilisée pour décrire
+                un paramètre de méthode. Chacun doit avoir une position (sinon l'ordre de leur enregistrement
+                sera utilisé par défaut), une valeur par défaut, un type et enfin un nom.
+            </para>
+
+            <para>
+                Voici l'API:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Parameter extends Zend_CodeGenerator_Php_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Parameter $reflectionParameter
+    )
+    public function setType($type)
+    public function getType()
+    public function setName($name)
+    public function getName()
+    public function setDefaultValue($defaultValue)
+    public function getDefaultValue()
+    public function setPosition($position)
+    public function getPosition()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-property">
+            <title>Zend_CodeGenerator_Php_Property</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Property</classname> est utilisée pour décrire une propriété
+                PHP, nous entendons par là une variable ou une constante PHP. Une valeur par défaut peut alors
+                être spécifiée. La visibilité de la propriété peut être définie par la classe parente,
+                <classname>Zend_CodeGenerator_Php_Member_Abstract</classname>.
+            </para>
+
+            <para>
+                Voici l'API:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Property
+    extends Zend_CodeGenerator_Php_Member_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Property $reflectionProperty
+    )
+    public function setConst($const)
+    public function isConst()
+    public function setDefaultValue($defaultValue)
+    public function getDefaultValue()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+    </sect2>
+</sect1>

documentation/manual/fr/module_specs/Zend_Reflection-Examples.xml

@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.reflection.examples">
+    <title>Zend_Reflection Exemples</title>
+
+    <example id="zend.reflection.examples.file">
+        <title>Effectuer la réflexion sur un fichier</title>
+
+        <programlisting role="php"><![CDATA[
+$r = new Zend_Reflection_File($filename);
+printf(
+    "===> The %s file\n".
+    "     has %d lines\n",
+    $r->getFileName(),
+    $r->getEndLine()
+);
+
+$classes = $r->getClasses();
+echo "     It has " . count($classes) . ":\n";
+foreach ($classes as $class) {
+    echo "         " . $class->getName() . "\n";
+}
+
+$functions = $r->getFunctions();
+echo "     It has " . count($functions) . ":\n";
+foreach ($functions as $function) {
+    echo "         " . $function->getName() . "\n";
+}
+
+]]></programlisting>
+    </example>
+
+    <example id="zend.reflection.examples.class">
+        <title>Effectuer la réflexion d'une classe</title>
+
+        <programlisting role="php"><![CDATA[
+$r = new Zend_Reflection_Class($class);
+
+printf(
+    "The class level docblock has the short description: %s\n".
+    "The class level docblock has the long description:\n%s\n",
+    $r->getDocblock()->getShortDescription(),
+    $r->getDocblock()->getLongDescription(),
+);
+
+// Get the declaring file reflection
+$file = $r->getDeclaringFile();
+]]></programlisting>
+    </example>
+
+    <example id="zend.reflection.examples.method">
+        <title>Effectuer la réflexion d'une méthode</title>
+
+        <programlisting role="php"><![CDATA[
+$r = new Zend_Reflection_Method($class, $name);
+
+printf(
+"The method '%s' has a return type of %s",
+    $r->getName(),
+    $r->getReturn()
+);
+
+foreach ($r->getParameters() as $key => $param) {
+    printf(
+        "Param at position '%d' is of type '%s'\n",
+        $key,
+        $param->getType()
+    );
+}
+]]></programlisting>
+    </example>
+
+    <example id="zend.reflection.examples.docblock">
+        <title>Effectuer la réflexion d'un bloc de documentation</title>
+
+        <programlisting role="php"><![CDATA[
+$r = new Zend_Reflection_Method($class, $name);
+$docblock = $r->getDocblock();
+
+printf(
+    "The short description: %s\n".
+    "The long description:\n%s\n",
+    $r->getDocblock()->getShortDescription(),
+    $r->getDocblock()->getLongDescription(),
+);
+
+foreach ($docblock->getTags() as $tag) {
+    printf(
+        "Annotation tag '%s' has the description '%s'\n",
+        $tag->getName(),
+        $tag->getDescription()
+    );
+}
+]]></programlisting>
+    </example>
+</sect1>

documentation/manual/fr/module_specs/Zend_Reflection-Introduction.xml

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.reflection.introduction">
+    <title>Introduction</title>
+
+    <para>
+        <classname>Zend_Reflection</classname> est un ensemble de fonctionnalités écrites par dessus <ulink
+            url="http://php.net/reflection">l'API Reflection de PHP</ulink>, et propose un ensemble de nouvelles
+            fonctionnalités:
+    </para>
+
+    <itemizedlist>
+        <listitem><para>
+            Possibilité de récupérer les types de retour des valeurs.
+        </para></listitem>
+
+        <listitem><para>
+            Possibilité de récupérer les types des paramètres de fonctions.
+        </para></listitem>
+
+        <listitem><para>
+            Possibilité de récupérer les types des attributs de classes.
+        </para></listitem>
+
+        <listitem><para>
+            Les blocs de commentaires PHPDoc possèdent aussi une classe de réflexion.
+            Ceci permet de récupérer un bloc précis de documentation, notamment son
+            nom, sa valeur et sa description, longue ou courte.
+        </para></listitem>
+
+        <listitem><para>
+            Les fichiers aussi possèdent leur propre classe de réflexion. Ceci permet
+            l'introspection de fichiers PHP afin de déterminer les classes et fonctions
+            écrites dans un fichier.
+        </para></listitem>
+
+        <listitem><para>
+             La possibilité de remplacer n'importe quelle classe de réflexion par la votre
+             propre.
+        </para></listitem>
+    </itemizedlist>
+
+    <para>
+        En général, <classname>Zend_Reflection</classname> fonctionne de la même manière que l'API
+        Reflection de PHP, elle propose par contre de nouvelles fonctionnalités.
+    </para>
+</sect1>

documentation/manual/fr/module_specs/Zend_Reflection-Reference.xml

@@ -0,0 +1,380 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.reflection.reference">
+    <title>Réference de Zend_Reflection</title>
+
+    <para>
+        Les classes de <code>Zend_Reflection</code> reprennent l'API de
+        <ulink url="http://php.net/reflection">la Reflection PHP</ulink> - mais avec
+        une différence importante : la Reflection PHP ne propose pas de manière d'introspecter
+        les tags de documentation PHPDoc, ni les types des variables paramètres ou encore
+        les types de retour des fonctions.
+    </para>
+
+    <para>
+        <code>Zend_Reflection</code> analyse les commentaires PHPDoc pour déterminer les types
+        des variables passées en paramètres ou de retour. Plus spécialement, les annotations
+        <code>@param</code> et <code>@return</code> sont utilisées, même s'il reste possible
+        d'analyser les autres blocs de commentaire, ainsi que leurs descriptions respectives.
+    </para>
+
+    <para>
+        Chaque objet de réflexion dans <code>Zend_Reflection</code>, surcharge la méthode
+        <code>getDocblock()</code> pour retourner une instance de
+        <code>Zend_Reflection_Docblock</code>. Cette classe propose alors l'introspection
+        des blocs de commentaires et notamment des tags PHPDoc.
+    </para>
+
+    <para>
+        <code>Zend_Reflection_File</code> est une nouvelle classe qui permet d'introspecter les fichiers PHP
+        à la recherche de classes, fonctions ou encore code global PHP contenu à l'intérieur.
+    </para>
+
+    <para>
+        Enfin, la plupart des méthodes qui retournent des objets réflexion acceptent un second paramètre
+        permettant de spécifier la classe qui sera instanciée pour créer de tels objets.
+    </para>
+
+    <sect2 id="zend.reflection.reference.docblock">
+        <title>Zend_Reflection_Docblock</title>
+
+        <para>
+            <code>Zend_Reflection_Docblock</code> est le coeur de la valeur ajoutée par
+            <code>Zend_Reflection</code> par rapport à la Reflection PHP.
+            Voici les méthodes proposées:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>getContents()</code>: retourne tout le contenu du bloc.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getStartLine()</code>: retourne la position de départ du bloc dans
+                le fichier.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getEndLine()</code>: retourne la position de fin du bloc dans
+                le fichier.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getShortDescription()</code>: récupère la description courte
+                (en général la première ligne de commentaire).
+            </para></listitem>
+
+            <listitem><para>
+                <code>getLongDescription()</code>: récupère la description longue
+                du bloc.
+            </para></listitem>
+
+            <listitem><para>
+                <code>hasTag($name)</code>: détermine si le bloc possède un tag particulier.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getTag($name)</code>: Récupère un tag particulier ou <code>false</code>
+                si celui-ci est absent.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getTags($filter)</code>: Récupère tous les tags qui correspondent au filtre
+                <code>$filter</code>. Le type de retour est un tableau d'objets
+                <code>Zend_Reflection_Docblock_Tag</code>.
+            </para></listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.reflection.reference.docblock-tag">
+        <title>Zend_Reflection_Docblock_Tag</title>
+
+        <para>
+            <code>Zend_Reflection_Docblock_Tag</code> propose la réflexion pour un tag individuel.
+            La plupart des tags se composent d'un nom et d'un description. Dans le cas de certains
+            tags spéciaux, la classe propose une méthode de fabrique qui retourne la bonne instance.
+        </para>
+
+        <para>
+            Voici les méthodes de <code>Zend_Reflection_Docblock_Tag</code>:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>factory($tagDocblockLine)</code>: instancie la bonne classe de reflection
+                pour le tag correspondant et en retourne l'objet.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getName()</code>: retourne le nom du tag.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getDescription()</code>: retourne la description du tag.
+            </para></listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.reflection.reference.docblock-tag-param">
+        <title>Zend_Reflection_Docblock_Tag_Param</title>
+
+        <para>
+            <code>Zend_Reflection_Docblock_Tag_Param</code> est une version spéciale de
+            <code>Zend_Reflection_Docblock_Tag</code>. La description du tag
+            <code>@param</code> consiste en un type, un nom de variable et une description.
+            Elle ajoute les méthodes suivantes à <code>Zend_Reflection_Docblock_Tag</code>:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>getType()</code>: Retourne le type de la variable considérée par le tag.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getVariableName()</code>: Retourne le nom de la variable considérée par le tag.
+            </para></listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.reflection.reference.docblock-tag-return">
+        <title>Zend_Reflection_Docblock_Tag_Return</title>
+
+        <para>
+            Comme <code>Zend_Reflection_Docblock_Tag_Param</code>,
+            <code>Zend_Reflection_Docblock_Tag_Return</code> est une version spéciale de
+            <code>Zend_Reflection_Docblock_Tag</code>. Le tag
+            <code>@return</code> consiste en un type de retour et une description.
+            Elle ajoute les méthodes suivantes à <code>Zend_Reflection_Docblock_Tag</code>:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>getType()</code>: retourne le type de retour.
+            </para></listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.reflection.reference.file">
+        <title>Zend_Reflection_File</title>
+
+        <para>
+            <code>Zend_Reflection_File</code> propose l'introspection de fichiers PHP.
+            Grâce à cela, vous pouvez déterminer les classes, fonctions ou le code pur PHP contenus
+            dans un fichier PHP donné. Voici les méthodes proposées:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>getFileName()</code>: Retourne le nom du fichier en cours de réflexion.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getStartLine()</code>: Retourne la ligne de démarrage du fichier (toujours "1").
+            </para></listitem>
+
+            <listitem><para>
+                <code>getEndLine()</code> Retourne la dernière ligne du fichier, donc le nombre de lignes.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getDocComment($reflectionClass =
+                    'Zend_Reflection_Docblock')</code>: Retourne un objet de réflection de commentaire
+                    PHPDoc du fichier en cours d'analyse.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getClasses($reflectionClass =
+                    'Zend_Reflection_Class')</code>: Retourne un tableau d'objets de réflexion de classe,
+                    pour les classes contenues dans le fichier en cours d'analyse.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getFunctions($reflectionClass =
+                    'Zend_Reflection_Function')</code>:  Retourne un tableau d'objets de réflexion de fonction,
+                    pour les fonctions contenues dans le fichier en cours d'analyse.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getClass($name = null, $reflectionClass =
+                    'Zend_Reflection_Class')</code>: Retourne l'objet de réflexion pour la classe contenue dans
+                    le fichier en cours d'analyse.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getContents()</code>: Retourne tout le contenu du fichier en cours d'analyse.
+            </para></listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.reflection.reference.class">
+        <title>Zend_Reflection_Class</title>
+
+        <para>
+            <code>Zend_Reflection_Class</code> étend
+            <code>ReflectionClass</code>, et propose son API. Elle ajoute juste une méthode,
+            <code>getDeclaringFile()</code>, qui peut être utilisée pour créer un objet
+            <code>Zend_Reflection_File</code>.
+        </para>
+
+        <para>
+            Aussi, les méthodes suivantes proposent un argument supplémentaire pour spécifier sa propre
+            classe de réflexion:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>getDeclaringFile($reflectionClass = 'Zend_Reflection_File')</code>
+            </para></listitem>
+
+            <listitem><para>
+                <code>getDocblock($reflectionClass = 'Zend_Reflection_Docblock')</code>
+            </para></listitem>
+
+            <listitem><para>
+                <code>getInterfaces($reflectionClass = 'Zend_Reflection_Class')</code>
+            </para></listitem>
+
+            <listitem><para>
+                <code>getMethod($reflectionClass = 'Zend_Reflection_Method')</code>
+            </para></listitem>
+
+            <listitem><para>
+                <code>getMethods($filter = -1, $reflectionClass = 'Zend_Reflection_Method')</code>
+            </para></listitem>
+
+            <listitem><para>
+                <code>getParentClass($reflectionClass = 'Zend_Reflection_Class')</code>
+            </para></listitem>
+
+            <listitem><para>
+                <code>getProperty($name, $reflectionClass =
+                    'Zend_Reflection_Property')</code>
+            </para></listitem>
+
+            <listitem><para>
+                <code>getProperties($filter = -1, $reflectionClass =
+                    'Zend_Reflection_Property')</code>
+            </para></listitem>
+
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.reflection.reference.extension">
+        <title>Zend_Reflection_Extension</title>
+
+        <para>
+            <code>Zend_Reflection_Extension</code> étend
+            <code>ReflectionExtension</code> et propose son API. Elle surcharge
+            les méthodes suivantes afin d'ajouter un paramètre permettant de spécifier
+            sa propre classe de réflexion:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>getFunctions($reflectionClass =
+                    'Zend_Reflection_Function')</code>: retourne un tableau d'objets réflexion
+                représentants les fonctions définies par l'extension en question.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getClasses($reflectionClass =
+                    'Zend_Reflection_Class')</code>: retourne un tableau d'objets réflexion
+                représentants les classes définies par l'extension en question.
+            </para></listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.reflection.reference.function">
+        <title>Zend_Reflection_Function</title>
+
+        <para>
+            <code>Zend_Reflection_Function</code> ajoute une méthode pour retrouver le type de retour
+            de la fonction introspéctée, et surcharge d'autres méthodes pour proposer de passer en paramètre
+            une classe de réflexion à utiliser.
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>getDocblock($reflectionClass =
+                    'Zend_Reflection_Docblock')</code>: Retourne un objet représentant les blocs de documentation.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getParameters($reflectionClass =
+                    'Zend_Reflection_Parameter')</code>: Retourne un tableau représentant les paramètres
+                    de la fonction analysée sous forme d'objets réflexion.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getReturn()</code>: Retourne le type de retour sous forme d'objet réflexion
+            </para></listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.reflection.reference.method">
+        <title>Zend_Reflection_Method</title>
+
+        <para>
+            <code>Zend_Reflection_Method</code> reprend l'API de
+            <code>Zend_Reflection_Function</code> et surcharge la méthode suivante:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>getParentClass($reflectionClass =
+                    'Zend_Reflection_Class')</code>: Retourne un objet réflexion de la classe parente
+            </para></listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.reflection.reference.parameter">
+        <title>Zend_Reflection_Parameter</title>
+
+        <para>
+            <code>Zend_Reflection_Parameter</code> ajoute une méthode pour retrouver le type
+            d'un paramètre, et aussi surcharge certaines méthodes en rajoutant un paramètre
+            permettant de spécifier sa propre classe de réflexion.
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>getDeclaringClass($reflectionClass =
+                    'Zend_Reflection_Class')</code>: Retourne un objet réflexion représentant la classe
+                    de déclaration du paramètre (si disponible).
+            </para></listitem>
+
+            <listitem><para>
+                <code>getClass($reflectionClass =
+                    'Zend_Reflection_Class')</code>: Retourne un objet réflexion représentant la classe
+                    de l'objet passé comme paramètre (si disponible).
+            </para></listitem>
+
+            <listitem><para>
+                <code>getDeclaringFunction($reflectionClass =
+                    'Zend_Reflection_Function')</code>: Retourne un objet réflexion représentant la fonction
+                    passée comme paramètre (si disponible).
+            </para></listitem>
+
+            <listitem><para>
+                <code>getType()</code>: Retourne le type du paramètre.
+            </para></listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.reflection.reference.property">
+        <title>Zend_Reflection_Property</title>
+
+        <para>
+            <code>Zend_Reflection_Property</code> surcharge une seule méthode afin de pouvoir spécifier
+            le type de classe de retour:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>getDeclaringClass($reflectionClass =
+                    'Zend_Reflection_Class')</code>: Retourne un objet réflexion représentant la classe
+                    de l'objet passé comme paramètre (si disponible).
+            </para></listitem>
+        </itemizedlist>
+    </sect2>
+</sect1>

documentation/manual/fr/module_specs/Zend_Tag-Introduction.xml

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.tag.introduction">
+    <title>Introduction</title>
+
+    <para>
+        <classname>Zend_Tag</classname> est une suite de composants permettant de manipuler des entités
+        taguables. Ce composant propose 2 classes dans ce but, <classname>Zend_Tag_Item</classname> et
+        <classname>Zend_Tag_ItemList</classname>. Aussi, l'interface
+        <classname>Zend_Tag_Taggable</classname> vous permet d'utiliser vos modèles dans des tags avec
+        <classname>Zend_Tag</classname>.
+    </para>
+
+    <para>
+        <classname>Zend_Tag_Item</classname> est un composant proposant les fonctionnalités basiques
+        pour traiter des tags dans <classname>Zend_Tag</classname>. Une entités taguables consiste en un titre
+        et un poids (nombre d'occurences). Il existe aussi d'autres paramètres utilisés par
+        <classname>Zend_Tag</classname>.
+    </para>
+
+    <para>
+        Pour grouper plusieurs entités ensemble, <classname>Zend_Tag_ItemList</classname> propose un itérateur de tableau
+        et des fonctions pour calculer le poids absolu des valeurs en fonction du poids de chaque entité.
+    </para>
+
+    <example id="zend.tag.example.using">
+        <title>Utiliser Zend_Tag</title>
+        <para>
+            Cet exemple montre comment créer une liste de tags en pondérant chacun d'eux.
+        </para>
+        <programlisting role="php"><![CDATA[
+// Crée la liste
+$list = new Zend_Tag_ItemList();
+
+// Ajoute des entités dans la liste
+$list[] = new Zend_Tag_Item(array('title' => 'Code', 'weight' => 50));
+$list[] = new Zend_Tag_Item(array('title' => 'Zend Framework', 'weight' => 1));
+$list[] = new Zend_Tag_Item(array('title' => 'PHP', 'weight' => 5));
+
+// Valeurs absolues des entités
+$list->spreadWeightValues(array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+
+// Sortie
+foreach ($list as $item) {
+    printf("%s: %d\n", $item->getTitle(), $item->getParam('weightValue'));
+}
+]]></programlisting>
+        <para>
+            Ceci va afficher les 3 entités Code, Zend Framework et PHP avec les valeurs
+            absolues 10, 1 et 2.
+        </para>
+    </example>
+</sect1>

documentation/manual/fr/module_specs/Zend_Tag_Cloud.xml

@@ -0,0 +1,192 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.tag.cloud">
+
+    <title>Zend_Tag_Cloud</title>
+
+    <para>
+        <classname>Zend_Tag_Cloud</classname> est la partie qui s'occupe du rendu dans
+        <classname>Zend_Tag</classname>. par défaut, elle utilise un ensemble de décorateurs HTML
+        , ce qui permet de créer des nuages de tags pour un site, mais elle met aussi à votre
+        disposition 2 classes abstraites vous permettant de créer vos propres rendus, par exemple pour
+        créer des tags rendus en PDF.
+    </para>
+
+    <para>
+        Vous pouvez instancier et configurer <classname>Zend_Tag_Cloud</classname> de manière classique,
+        ou via un tableau ou un objet <classname>Zend_Config</classname>. Voici les options disponibles:
+    </para>
+
+    <itemizedlist>
+        <listitem>
+            <para>
+                <code>cloudDecorator</code>: défini le décorateur du nuage. Ceci peut être un objet,
+                un nom de classe qui sera chargée par pluginloader, une instance de
+                <classname>Zend_Tag_Cloud_Decorator_Cloud</classname> ou un tableau contenant les clés
+                <code>decorator</code> et optionnellement <code>options</code>, qui est elle-même
+                un tableau passé comme options au constructeur du décorateur.
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+                <code>tagDecorator</code>: Le décorateur d'un tag individuel. Ceci peut être un objet,
+                un nom de classe qui sera chargée par pluginloader, une instance de
+                <classname>Zend_Tag_Cloud_Decorator_Cloud</classname> ou un tableau contenant les clés
+                <code>decorator</code> et optionnellement <code>options</code>, qui est elle-même
+                un tableau passé comme options au constructeur du décorateur.
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+                <code>pluginLoader</code>: un chargeur de classe à utiliser.
+                Doit implémenter l'interface <classname>Zend_Loader_PluginLoader_Interface</classname>.
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+                <code>prefixPath</code>: prefixes de chemins à ajouter au chargeur de classes.
+                Doit être un tableau contenant les préfixes et les chemins. Les éléments invalides
+                seront ignorés.
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+                <code>itemList</code>: une liste d'entités à utiliser. Doit être instance de
+                <classname>Zend_Tag_ItemList</classname>.
+            </para>
+        </listitem>
+        <listitem>
+            <para>
+                <code>tags</code>: une liste de tags à assigner au nuage. Chacun doit implémenter
+                <classname>Zend_Tag_Taggable</classname> ou être un tableau qui pourra être utilisé pour
+                instancier <classname>Zend_Tag_Item</classname>.
+            </para>
+        </listitem>
+    </itemizedlist>
+
+    <example id="zend.tag.cloud.example.using">
+
+        <title>Utiliser Zend_Tag_Cloud</title>
+
+        <para>
+            Cet exemple illustre les manipulations de base pour créer un nuage de tags, ajouter des tags et afficher
+            le rendu.
+        </para>
+        <programlisting role="php"><![CDATA[
+// Crée un nuage et assigne des tags statiques
+$cloud = new Zend_Tag_Cloud(array(
+    'tags' => array(
+        array('title' => 'Code', 'weight' => 50,
+              'params' => array('url' => '/tag/code')),
+        array('title' => 'Zend Framework', 'weight' => 1,
+              'params' => array('url' => '/tag/zend-framework')),
+        array('title' => 'PHP', 'weight' => 5,
+              'params' => array('url' => '/tag/php')),
+    )
+));
+
+// Rendu du nuage
+echo $cloud;
+]]></programlisting>
+        <para>
+            Ceci affichera le nuage de tags, avec les polices par défaut.
+        </para>
+    </example>
+
+    <sect2 id="zend.tag.cloud.decorators">
+
+        <title>Decorateurs</title>
+
+        <para>
+            <classname>Zend_Tag_Cloud</classname> a besoin de 2 types de décorateurs afin de rendre
+            le nuage. Un décorateur pour rendre chacun des tags, et un décorateur pour rendre le nuage lui-même.
+            <classname>Zend_Tag_Cloud</classname> propose un décorateur par défaut qui formate le nuage en HTML.
+            Il utilise par défaut des listes ul/li et des tailles de polices différentes selon les poids des tags.
+        </para>
+
+        <sect3 id="zend.tag.cloud.decorators.htmltag">
+
+            <title>Décorateur HTML</title>
+
+            <para>
+                Le décorateur HTML va rendre chaque tag dans un élément ancré, entouré d'un élément li.
+                L'ancre est fixe et ne peut être changée, mais l'élément peut lui l'être.
+            </para>
+
+            <note>
+                <title>Paramètre d'URL</title>
+                <para>
+                    Une ancre étant ajoutée à chaque tag, vous devez spécifier une URL pour chacun d'eux.
+                </para>
+            </note>
+
+            <para>
+                Le décorateur de tags peut utiliser des tailles de police différentes pour chaque ancre,
+                ou pour chaque classe de liste. Les options suivantes sont disponibles:
+            </para>
+
+            <itemizedlist>
+                <listitem>
+                    <para>
+                        <code>fontSizeUnit</code>: définit l'unité utilisée dans la taille des polices.
+                        em, ex, px, in, cm, mm, pt, pc et &#37;.
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>
+                        <code>minFontSize</code>: Taille minimale de la police (poids le plus faible)
+                        (doit être un entier).
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>
+                        <code>maxFontSize</code>: Taille maximale de la police (poids le plus fort)
+                        (doit être un entier).
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>
+                        <code>classList</code>: un tableau de classes utilisées dans les tags.
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>
+                        <code>htmlTags</code>: un tableau de tags HTML entourant l'ancre. Chaque élément
+                        peut être une chaine de caractères, utilisée comme type d'élément, ou un tableau
+                        contenant une liste d'attributs pour l'élément. La clé du tableau est alors utlisée
+                        pour définir le type de l'élément.
+                    </para>
+                </listitem>
+            </itemizedlist>
+        </sect3>
+
+        <sect3 id="zend.tag.cloud.decorators.htmlcloud">
+
+            <title>Décorateur HTML de nuage</title>
+
+            <para>
+                Le décorateur HTML de nuage va entourer les tags avec une balise ul.
+                Vous pouvez changer la balise, en utiliser plusieurs, utiliser un séparateur.
+                Voici les options:
+            </para>
+
+            <itemizedlist>
+                <listitem>
+                    <para>
+                        <code>separator</code>: définit le séparateur utilisé entre chaque tag.
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>
+                        <code>htmlTags</code>: un tableau de balises HTML entourant chaque tag.
+                        Chaque élément peut être une chaine de caractères, utilisée comme type
+                        d'élément, ou un tableau contenant une liste d'attributs pour l'élément.
+                        La clé du tableau est alors utlisée pour définir le type de l'élément.
+                    </para>
+                </listitem>
+            </itemizedlist>
+        </sect3>
+
+    </sect2>
+
+</sect1>