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

   1 <?xml version="1.0" encoding="UTF-8"?>
   2     <!-- EN-Revision: 20765 -->
   3     <!-- Reviewed: no -->
   4 <sect1 id="zend.codegenerator.examples">
   5     <title>Ejemplos de Zend_CodeGenerator</title>
   6
   7     <example id="zend.codegenerator.examples.class">
   8         <title>Generando clases PHP</title>
   9
  10         <para>El siguiente ejemplo genera una clase vacía con una clase de
  11             nivel DocBlock.</para>
  12
  13         <programlisting language="php"><![CDATA[
  14 $foo      = new Zend_CodeGenerator_Php_Class();
  15 $docblock = new Zend_CodeGenerator_Php_Docblock(array(
  16     'shortDescription' => 'Sample generated class',
  17     'longDescription'  => 'This is a class generated with Zend_CodeGenerator.',
  18     'tags'             => array(
  19         array(
  20             'name'        => 'version',
  21             'description' => '$Rev:$',
  22         ),
  23         array(
  24             'name'        => 'license',
  25             'description' => 'New BSD',
  26         ),
  27     ),
  28 ));
  29 $foo->setName('Foo')
  30     ->setDocblock($docblock);
  31 echo $foo->generate();
  32 ]]></programlisting>
  33
  34         <para>El código anterior resultará en lo siguiente:</para>
  35
  36         <programlisting language="php"><![CDATA[
  37 /**
  38  * Sample generated class
  39  *
  40  * This is a class generated with Zend_CodeGenerator.
  41  *
  42  * @version $Rev:$
  43  * @license New BSD
  44  *
  45  */
  46 class Foo
  47 {
  48
  49 }
  50 ]]></programlisting>
  51     </example>
  52
  53     <example id="zend.codegenerator.examples.class-properties">
  54         <title>Generando clases PHP con propiedades de clase</title>
  55
  56         <para>Basándonos en el ejemplo anterior, ahora agreguemos propiedades a
  57             nuestra clase
  58             generada.</para>
  59
  60         <programlisting language="php"><![CDATA[
  61 $foo      = new Zend_CodeGenerator_Php_Class();
  62 $docblock = new Zend_CodeGenerator_Php_Docblock(array(
  63     'shortDescription' => 'Sample generated class',
  64     'longDescription'  => 'This is a class generated with Zend_CodeGenerator.',
  65     'tags'             => array(
  66         array(
  67             'name'        => 'version',
  68             'description' => '$Rev:$',
  69         ),
  70         array(
  71             'name'        => 'license',
  72             'description' => 'New BSD',
  73         ),
  74     ),
  75 ));
  76 $foo->setName('Foo')
  77     ->setDocblock($docblock)
  78     ->setProperties(array(
  79         array(
  80             'name'         => '_bar',
  81             'visibility'   => 'protected',
  82             'defaultValue' => 'baz',
  83         ),
  84         array(
  85             'name'         => 'baz',
  86             'visibility'   => 'public',
  87             'defaultValue' => 'bat',
  88         ),
  89         array(
  90             'name'         => 'bat',
  91             'const'        => true,
  92             'defaultValue' => 'foobarbazbat',
  93         ),
  94     ));
  95 echo $foo->generate();
  96 ]]></programlisting>
  97
  98         <para>Lo anterior resulta en la siguiente definición de clase:</para>
  99
 100         <programlisting language="php"><![CDATA[
 101 /**
 102  * Sample generated class
 103  *
 104  * This is a class generated with Zend_CodeGenerator.
 105  *
 106  * @version $Rev:$
 107  * @license New BSD
 108  *
 109  */
 110 class Foo
 111 {
 112
 113     protected $_bar = 'baz';
 114
 115     public $baz = 'bat';
 116
 117     const bat = 'foobarbazbat';
 118
 119 }
 120 ]]></programlisting>
 121     </example>
 122
 123     <example id="zend.codegenerator.examples.class-methods">
 124         <title>Generando clases PHP con métodos de clase</title>
 125
 126         <para>
 127             <classname>Zend_CodeGenerator_Php_Class</classname>
 128             le permite
 129             adjuntar métodos con contenido opcional a sus clases. Los métodos
 130             pueden
 131             adjuntarse tanto como arrys o como instancias concretas de
 132             <classname>Zend_CodeGenerator_Php_Method</classname>
 133             .
 134         </para>
 135
 136         <programlisting language="php"><![CDATA[
 137 $foo      = new Zend_CodeGenerator_Php_Class();
 138 $docblock = new Zend_CodeGenerator_Php_Docblock(array(
 139     'shortDescription' => 'Sample generated class',
 140     'longDescription'  => 'This is a class generated with Zend_CodeGenerator.',
 141     'tags'             => array(
 142         array(
 143             'name'        => 'version',
 144             'description' => '$Rev:$',
 145         ),
 146         array(
 147             'name'        => 'license',
 148             'description' => 'New BSD',
 149         ),
 150     ),
 151 ));
 152 $foo->setName('Foo')
 153     ->setDocblock($docblock)
 154     ->setProperties(array(
 155         array(
 156             'name'         => '_bar',
 157             'visibility'   => 'protected',
 158             'defaultValue' => 'baz',
 159         ),
 160         array(
 161             'name'         => 'baz',
 162             'visibility'   => 'public',
 163             'defaultValue' => 'bat',
 164         ),
 165         array(
 166             'name'         => 'bat',
 167             'const'        => true,
 168             'defaultValue' => 'foobarbazbat',
 169         ),
 170     ))
 171     ->setMethods(array(
 172         // Método pasado como array
 173         array(
 174             'name'       => 'setBar',
 175             'parameters' => array(
 176                 array('name' => 'bar'),
 177             ),
 178             'body'       => '$this->_bar = $bar;' . "\n" . 'return $this;',
 179             'docblock'   => new Zend_CodeGenerator_Php_Docblock(array(
 180                 'shortDescription' => 'Set the bar property',
 181                 'tags'             => array(
 182                     new Zend_CodeGenerator_Php_Docblock_Tag_Param(array(
 183                         'paramName' => 'bar',
 184                         'datatype'  => 'string'
 185                     )),
 186                     new Zend_CodeGenerator_Php_Docblock_Tag_Return(array(
 187                         'datatype'  => 'string',
 188                     )),
 189                 ),
 190             )),
 191         ),
 192         // Método pasado como instancia concreta
 193         new Zend_CodeGenerator_Php_Method(array(
 194             'name' => 'getBar',
 195             'body'       => 'return $this->_bar;',
 196             'docblock'   => new Zend_CodeGenerator_Php_Docblock(array(
 197                 'shortDescription' => 'Retrieve the bar property',
 198                 'tags'             => array(
 199                     new Zend_CodeGenerator_Php_Docblock_Tag_Return(array(
 200                         'datatype'  => 'string|null',
 201                     )),
 202                 ),
 203             )),
 204         )),
 205     ));
 206
 207 echo $foo->generate();
 208 ]]></programlisting>
 209
 210         <para>Lo anterior genera la siguiente salida:</para>
 211
 212         <programlisting language="php"><![CDATA[
 213 /**
 214  * Sample generated class
 215  *
 216  * This is a class generated with Zend_CodeGenerator.
 217  *
 218  * @version $Rev:$
 219  * @license New BSD
 220  */
 221 class Foo
 222 {
 223
 224     protected $_bar = 'baz';
 225
 226     public $baz = 'bat';
 227
 228     const bat = 'foobarbazbat';
 229
 230     /**
 231      * Set the bar property
 232      *
 233      * @param string bar
 234      * @return string
 235      */
 236     public function setBar($bar)
 237     {
 238         $this->_bar = $bar;
 239         return $this;
 240     }
 241
 242     /**
 243      * Retrieve the bar property
 244      *
 245      * @return string|null
 246      */
 247     public function getBar()
 248     {
 249         return $this->_bar;
 250     }
 251
 252 }
 253 ]]></programlisting>
 254     </example>
 255
 256     <example id="zend.codegenerator.examples.file">
 257         <title>Generando archivos PHP</title>
 258
 259         <para>
 260             <classname>Zend_CodeGenerator_Php_File</classname>
 261             puede ser
 262             utilizada para generar el contenido de un archivo
 263             <acronym>PHP</acronym>
 264             . Usted puede incluir clases, así como el
 265             contenido arbitrario del cuerpo. Cuando acople
 266             clases, debe adjuntar
 267             instancias concretas de
 268             <classname>Zend_CodeGenerator_Php_Class</classname>
 269             o un array
 270             definiendo la clase.
 271         </para>
 272
 273         <para>
 274             En el ejemplo siguiente, asumiremos que ha definido
 275             <varname>$foo</varname>
 276             como una de las definiciones de clase
 277             del ejemplo anterior.
 278         </para>
 279
 280         <programlisting language="php"><![CDATA[
 281 $file = new Zend_CodeGenerator_Php_File(array(
 282     'classes'  => array($foo);
 283     'docblock' => new Zend_CodeGenerator_Php_Docblock(array(
 284         'shortDescription' => 'Foo class file',
 285         'tags'             => array(
 286             array(
 287                 'name'        => 'license',
 288                 'description' => 'New BSD',
 289             ),
 290         ),
 291     )),
 292     'body'     => 'define(\'APPLICATION_ENV\', \'testing\');',
 293 ));
 294 ]]></programlisting>
 295
 296         <para>
 297             Llamando a
 298             <methodname>generate()</methodname>
 299             generará el código
 300             -- pero no lo grabará en un archivo. Usted mismo deberá capturar y
 301             grabar los contenidos en un archivo. Por ejemplo:
 302         </para>
 303
 304         <programlisting language="php"><![CDATA[
 305 $code = $file->generate();
 306 file_put_contents('Foo.php', $code);
 307 ]]></programlisting>
 308
 309         <para>Lo anterior generará el siguiente archivo:</para>
 310
 311         <programlisting language="php"><![CDATA[
 312 <?php
 313 /**
 314  * Foo class file
 315  *
 316  * @license New BSD
 317  */
 318
 319 /**
 320  * Sample generated class
 321  *
 322  * This is a class generated with Zend_CodeGenerator.
 323  *
 324  * @version $Rev:$
 325  * @license New BSD
 326  */
 327 class Foo
 328 {
 329
 330     protected $_bar = 'baz';
 331
 332     public $baz = 'bat';
 333
 334     const bat = 'foobarbazbat';
 335
 336     /**
 337      * Set the bar property
 338      *
 339      * @param string bar
 340      * @return string
 341      */
 342     public function setBar($bar)
 343     {
 344         $this->_bar = $bar;
 345         return $this;
 346     }
 347
 348     /**
 349      * Retrieve the bar property
 350      *
 351      * @return string|null
 352      */
 353     public function getBar()
 354     {
 355         return $this->_bar;
 356     }
 357
 358 }
 359
 360 define('APPLICATION_ENV', 'testing');
 361 ]]></programlisting>
 362     </example>
 363
 364     <example id="zend.codegenerator.examples.reflection-file">
 365         <title>Sembrando la generación de código para un archivo PHP via
 366             reflection</title>
 367         <para>
 368             You can add
 369             <acronym>PHP</acronym>
 370             code to an existing
 371             <acronym>PHP</acronym>
 372             file using the code generator. To do so,
 373             you need to first do reflection on it. The
 374             static method
 375             <methodname>fromReflectedFileName()</methodname>
 376             allows you to
 377             do this.
 378         </para>
 379
 380         <programlisting language="php"><![CDATA[
 381 $generator = Zend_CodeGenerator_Php_File::fromReflectedFileName($path);
 382 $body = $generator->getBody();
 383 $body .= "\n\$foo->bar();";
 384 file_put_contents($path, $generator->generate());
 385 ]]></programlisting>
 386     </example>
 387
 388     <example id="zend.codegenerator.examples.reflection-class">
 389         <title>Sembrando la generación de clases PHP via reflection</title>
 390         <para>
 391             You may add code to an existing class. To do so, first use the
 392             static
 393             <methodname>fromReflection()</methodname>
 394             method to map the
 395             class into a generator object. From there, you may add additional
 396             properties or methods, and then regenerate the class.
 397         </para>
 398
 399         <programlisting language="php"><![CDATA[
 400 $generator = Zend_CodeGenerator_Php_Class::fromReflection(
 401     new Zend_Reflection_Class($class)
 402 );
 403 $generator->setMethod(array(
 404     'name'       => 'setBaz',
 405     'parameters' => array(
 406         array('name' => 'baz'),
 407     ),
 408     'body'       => '$this->_baz = $baz;' . "\n" . 'return $this;',
 409     'docblock'   => new Zend_CodeGenerator_Php_Docblock(array(
 410         'shortDescription' => 'Set the baz property',
 411         'tags'             => array(
 412             new Zend_CodeGenerator_Php_Docblock_Tag_Param(array(
 413                 'paramName' => 'baz',
 414                 'datatype'  => 'string'
 415             )),
 416             new Zend_CodeGenerator_Php_Docblock_Tag_Return(array(
 417                 'datatype'  => 'string',
 418             )),
 419         ),
 420     )),
 421 ));
 422 $code = $generator->generate();
 423 ]]></programlisting>
 424     </example>
 425
 426     <example id="zend.codegenerator.examples.reflection-method">
 427         <title>Sembrando la generación de métodos PHP via reflection</title>
 428         <para>
 429             You may add code to an existing class. To do so, first use the
 430             static
 431             <methodname>fromReflection()</methodname>
 432             method to map the
 433             class into a generator object. From there, you may add additional
 434             properties or methods, and then regenerate the class.
 435         </para>
 436     </example>
 437 </sect1>