interface/modules/zend_modules/library/Zend/Code/Generator/ClassGenerator.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Code\Generator;
  11
  12 use Zend\Code\Reflection\ClassReflection;
  13
  14 class ClassGenerator extends AbstractGenerator
  15 {
  16     const FLAG_ABSTRACT = 0x01;
  17     const FLAG_FINAL    = 0x02;
  18
  19     /**
  20      * @var FileGenerator
  21      */
  22     protected $containingFileGenerator = null;
  23
  24     /**
  25      * @var string
  26      */
  27     protected $namespaceName = null;
  28
  29     /**
  30      * @var DocBlockGenerator
  31      */
  32     protected $docBlock = null;
  33
  34     /**
  35      * @var string
  36      */
  37     protected $name = null;
  38
  39     /**
  40      * @var bool
  41      */
  42     protected $flags = 0x00;
  43
  44     /**
  45      * @var string
  46      */
  47     protected $extendedClass = null;
  48
  49     /**
  50      * @var array Array of string names
  51      */
  52     protected $implementedInterfaces = array();
  53
  54     /**
  55      * @var PropertyGenerator[] Array of properties
  56      */
  57     protected $properties = array();
  58
  59     /**
  60      * @var MethodGenerator[] Array of methods
  61      */
  62     protected $methods = array();
  63
  64     /**
  65      * @var array Array of string names
  66      */
  67     protected $uses = array();
  68
  69     /**
  70      * Build a Code Generation Php Object from a Class Reflection
  71      *
  72      * @param  ClassReflection $classReflection
  73      * @return ClassGenerator
  74      */
  75     public static function fromReflection(ClassReflection $classReflection)
  76     {
  77         // class generator
  78         $cg = new static($classReflection->getName());
  79
  80         $cg->setSourceContent($cg->getSourceContent());
  81         $cg->setSourceDirty(false);
  82
  83         if ($classReflection->getDocComment() != '') {
  84             $cg->setDocBlock(DocBlockGenerator::fromReflection($classReflection->getDocBlock()));
  85         }
  86
  87         $cg->setAbstract($classReflection->isAbstract());
  88
  89         // set the namespace
  90         if ($classReflection->inNamespace()) {
  91             $cg->setNamespaceName($classReflection->getNamespaceName());
  92         }
  93
  94         /* @var \Zend\Code\Reflection\ClassReflection $parentClass */
  95         $parentClass = $classReflection->getParentClass();
  96         if ($parentClass) {
  97             $cg->setExtendedClass($parentClass->getName());
  98             $interfaces = array_diff($classReflection->getInterfaces(), $parentClass->getInterfaces());
  99         } else {
 100             $interfaces = $classReflection->getInterfaces();
 101         }
 102
 103         $interfaceNames = array();
 104         foreach ($interfaces AS $interface) {
 105             /* @var \Zend\Code\Reflection\ClassReflection $interface */
 106             $interfaceNames[] = $interface->getName();
 107         }
 108
 109         $cg->setImplementedInterfaces($interfaceNames);
 110
 111         $properties = array();
 112         foreach ($classReflection->getProperties() as $reflectionProperty) {
 113             if ($reflectionProperty->getDeclaringClass()->getName() == $classReflection->getName()) {
 114                 $properties[] = PropertyGenerator::fromReflection($reflectionProperty);
 115             }
 116         }
 117         $cg->addProperties($properties);
 118
 119         $methods = array();
 120         foreach ($classReflection->getMethods() as $reflectionMethod) {
 121             $className = ($cg->getNamespaceName())? $cg->getNamespaceName() . "\\" . $cg->getName() : $cg->getName();
 122             if ($reflectionMethod->getDeclaringClass()->getName() == $className) {
 123                 $methods[] = MethodGenerator::fromReflection($reflectionMethod);
 124             }
 125         }
 126         $cg->addMethods($methods);
 127
 128         return $cg;
 129     }
 130
 131     /**
 132      * Generate from array
 133      *
 134      * @configkey name           string        [required] Class Name
 135      * @configkey filegenerator  FileGenerator File generator that holds this class
 136      * @configkey namespacename  string        The namespace for this class
 137      * @configkey docblock       string        The docblock information
 138      * @configkey flags          int           Flags, one of ClassGenerator::FLAG_ABSTRACT ClassGenerator::FLAG_FINAL
 139      * @configkey extendedclass  string        Class which this class is extending
 140      * @configkey implementedinterfaces
 141      * @configkey properties
 142      * @configkey methods
 143      *
 144      * @throws Exception\InvalidArgumentException
 145      * @param  array $array
 146      * @return ClassGenerator
 147      */
 148     public static function fromArray(array $array)
 149     {
 150         if (!isset($array['name'])) {
 151             throw new Exception\InvalidArgumentException(
 152                 'Class generator requires that a name is provided for this object'
 153             );
 154         }
 155
 156         $cg = new static($array['name']);
 157         foreach ($array as $name => $value) {
 158             // normalize key
 159             switch (strtolower(str_replace(array('.', '-', '_'), '', $name))) {
 160                 case 'containingfile':
 161                     $cg->setContainingFileGenerator($value);
 162                     break;
 163                 case 'namespacename':
 164                     $cg->setNamespaceName($value);
 165                     break;
 166                 case 'docblock':
 167                     $docBlock = ($value instanceof DocBlockGenerator) ? $value : DocBlockGenerator::fromArray($value);
 168                     $cg->setDocBlock($docBlock);
 169                     break;
 170                 case 'flags':
 171                     $cg->setFlags($value);
 172                     break;
 173                 case 'extendedclass':
 174                     $cg->setExtendedClass($value);
 175                     break;
 176                 case 'implementedinterfaces':
 177                     $cg->setImplementedInterfaces($value);
 178                     break;
 179                 case 'properties':
 180                     $cg->addProperties($value);
 181                     break;
 182                 case 'methods':
 183                     $cg->addMethods($value);
 184                     break;
 185             }
 186         }
 187
 188         return $cg;
 189     }
 190
 191     /**
 192      * @param  string $name
 193      * @param  string $namespaceName
 194      * @param  array|string $flags
 195      * @param  string $extends
 196      * @param  array $interfaces
 197      * @param  array $properties
 198      * @param  array $methods
 199      * @param  DocBlockGenerator $docBlock
 200      */
 201     public function __construct($name = null, $namespaceName = null, $flags = null, $extends = null,
 202                                 $interfaces = array(), $properties = array(), $methods = array(), $docBlock = null)
 203     {
 204         if ($name !== null) {
 205             $this->setName($name);
 206         }
 207         if ($namespaceName !== null) {
 208             $this->setNamespaceName($namespaceName);
 209         }
 210         if ($flags !== null) {
 211             $this->setFlags($flags);
 212         }
 213         if ($properties !== array()) {
 214             $this->addProperties($properties);
 215         }
 216         if ($extends !== null) {
 217             $this->setExtendedClass($extends);
 218         }
 219         if (is_array($interfaces)) {
 220             $this->setImplementedInterfaces($interfaces);
 221         }
 222         if ($methods !== array()) {
 223             $this->addMethods($methods);
 224         }
 225         if ($docBlock !== null) {
 226             $this->setDocBlock($docBlock);
 227         }
 228     }
 229
 230     /**
 231      * @param  string $name
 232      * @return ClassGenerator
 233      */
 234     public function setName($name)
 235     {
 236         if (strstr($name, '\\')) {
 237             $namespace = substr($name, 0, strrpos($name, '\\'));
 238             $name      = substr($name, strrpos($name, '\\') + 1);
 239             $this->setNamespaceName($namespace);
 240         }
 241
 242         $this->name = $name;
 243         return $this;
 244     }
 245
 246     /**
 247      * @return string
 248      */
 249     public function getName()
 250     {
 251         return $this->name;
 252     }
 253
 254     /**
 255      * @param  string $namespaceName
 256      * @return ClassGenerator
 257      */
 258     public function setNamespaceName($namespaceName)
 259     {
 260         $this->namespaceName = $namespaceName;
 261         return $this;
 262     }
 263
 264     /**
 265      * @return string
 266      */
 267     public function getNamespaceName()
 268     {
 269         return $this->namespaceName;
 270     }
 271
 272     /**
 273      * @param  FileGenerator $fileGenerator
 274      * @return ClassGenerator
 275      */
 276     public function setContainingFileGenerator(FileGenerator $fileGenerator)
 277     {
 278         $this->containingFileGenerator = $fileGenerator;
 279         return $this;
 280     }
 281
 282     /**
 283      * @return FileGenerator
 284      */
 285     public function getContainingFileGenerator()
 286     {
 287         return $this->containingFileGenerator;
 288     }
 289
 290     /**
 291      * @param  DocBlockGenerator $docBlock
 292      * @return ClassGenerator
 293      */
 294     public function setDocBlock(DocBlockGenerator $docBlock)
 295     {
 296         $this->docBlock = $docBlock;
 297         return $this;
 298     }
 299
 300     /**
 301      * @return DocBlockGenerator
 302      */
 303     public function getDocBlock()
 304     {
 305         return $this->docBlock;
 306     }
 307
 308     /**
 309      * @param  array|string $flags
 310      * @return ClassGenerator
 311      */
 312     public function setFlags($flags)
 313     {
 314         if (is_array($flags)) {
 315             $flagsArray = $flags;
 316             $flags      = 0x00;
 317             foreach ($flagsArray as $flag) {
 318                 $flags |= $flag;
 319             }
 320         }
 321         // check that visibility is one of three
 322         $this->flags = $flags;
 323
 324         return $this;
 325     }
 326
 327     /**
 328      * @param  string $flag
 329      * @return ClassGenerator
 330      */
 331     public function addFlag($flag)
 332     {
 333         $this->setFlags($this->flags | $flag);
 334         return $this;
 335     }
 336
 337     /**
 338      * @param  string $flag
 339      * @return ClassGenerator
 340      */
 341     public function removeFlag($flag)
 342     {
 343         $this->setFlags($this->flags & ~$flag);
 344         return $this;
 345     }
 346
 347     /**
 348      * @param  bool $isAbstract
 349      * @return ClassGenerator
 350      */
 351     public function setAbstract($isAbstract)
 352     {
 353         return (($isAbstract) ? $this->addFlag(self::FLAG_ABSTRACT) : $this->removeFlag(self::FLAG_ABSTRACT));
 354     }
 355
 356     /**
 357      * @return bool
 358      */
 359     public function isAbstract()
 360     {
 361         return (bool) ($this->flags & self::FLAG_ABSTRACT);
 362     }
 363
 364     /**
 365      * @param  bool $isFinal
 366      * @return ClassGenerator
 367      */
 368     public function setFinal($isFinal)
 369     {
 370         return (($isFinal) ? $this->addFlag(self::FLAG_FINAL) : $this->removeFlag(self::FLAG_FINAL));
 371     }
 372
 373     /**
 374      * @return bool
 375      */
 376     public function isFinal()
 377     {
 378         return ($this->flags & self::FLAG_FINAL);
 379     }
 380
 381     /**
 382      * @param  string $extendedClass
 383      * @return ClassGenerator
 384      */
 385     public function setExtendedClass($extendedClass)
 386     {
 387         $this->extendedClass = $extendedClass;
 388         return $this;
 389     }
 390
 391     /**
 392      * @return string
 393      */
 394     public function getExtendedClass()
 395     {
 396         return $this->extendedClass;
 397     }
 398
 399     /**
 400      * @param  array $implementedInterfaces
 401      * @return ClassGenerator
 402      */
 403     public function setImplementedInterfaces(array $implementedInterfaces)
 404     {
 405         $this->implementedInterfaces = $implementedInterfaces;
 406         return $this;
 407     }
 408
 409     /**
 410      * @return array
 411      */
 412     public function getImplementedInterfaces()
 413     {
 414         return $this->implementedInterfaces;
 415     }
 416
 417     /**
 418      * @param  array $properties
 419      * @return ClassGenerator
 420      */
 421     public function addProperties(array $properties)
 422     {
 423         foreach ($properties as $property) {
 424             if ($property instanceof PropertyGenerator) {
 425                 $this->addPropertyFromGenerator($property);
 426             } else {
 427                 if (is_string($property)) {
 428                     $this->addProperty($property);
 429                 } elseif (is_array($property)) {
 430                     call_user_func_array(array($this, 'addProperty'), $property);
 431                 }
 432             }
 433         }
 434
 435         return $this;
 436     }
 437
 438     /**
 439      * Add Property from scalars
 440      *
 441      * @param  string $name
 442      * @param  string|array $defaultValue
 443      * @param  int $flags
 444      * @throws Exception\InvalidArgumentException
 445      * @return ClassGenerator
 446      */
 447     public function addProperty($name, $defaultValue = null, $flags = PropertyGenerator::FLAG_PUBLIC)
 448     {
 449         if (!is_string($name)) {
 450             throw new Exception\InvalidArgumentException(sprintf(
 451                 '%s expects string for name',
 452                 __METHOD__
 453             ));
 454         }
 455
 456         return $this->addPropertyFromGenerator(new PropertyGenerator($name, $defaultValue, $flags));
 457     }
 458
 459     /**
 460      * Add property from PropertyGenerator
 461      *
 462      * @param  string|PropertyGenerator           $property
 463      * @throws Exception\InvalidArgumentException
 464      * @return ClassGenerator
 465      */
 466     public function addPropertyFromGenerator(PropertyGenerator $property)
 467     {
 468         $propertyName = $property->getName();
 469
 470         if (isset($this->properties[$propertyName])) {
 471             throw new Exception\InvalidArgumentException(sprintf(
 472                 'A property by name %s already exists in this class.',
 473                 $propertyName
 474             ));
 475         }
 476
 477         $this->properties[$propertyName] = $property;
 478         return $this;
 479     }
 480
 481     /**
 482      * Add a class to "use" classes
 483      *
 484      * @param  string $use
 485      * @param  string|null $useAlias
 486      * @return ClassGenerator
 487      */
 488     public function addUse($use, $useAlias = null)
 489     {
 490         if (!empty($useAlias)) {
 491             $use .= ' as ' . $useAlias;
 492         }
 493
 494         $this->uses[$use] = $use;
 495         return $this;
 496     }
 497
 498     /**
 499      * @return PropertyGenerator[]
 500      */
 501     public function getProperties()
 502     {
 503         return $this->properties;
 504     }
 505
 506     /**
 507      * @param  string $propertyName
 508      * @return PropertyGenerator|false
 509      */
 510     public function getProperty($propertyName)
 511     {
 512         foreach ($this->getProperties() as $property) {
 513             if ($property->getName() == $propertyName) {
 514                 return $property;
 515             }
 516         }
 517
 518         return false;
 519     }
 520
 521     /**
 522      * Returns the "use" classes
 523      *
 524      * @return array
 525      */
 526     public function getUses()
 527     {
 528         return array_values($this->uses);
 529     }
 530
 531     /**
 532      * @param  string $propertyName
 533      * @return bool
 534      */
 535     public function hasProperty($propertyName)
 536     {
 537         return isset($this->properties[$propertyName]);
 538     }
 539
 540     /**
 541      * @param  array $methods
 542      * @return ClassGenerator
 543      */
 544     public function addMethods(array $methods)
 545     {
 546         foreach ($methods as $method) {
 547             if ($method instanceof MethodGenerator) {
 548                 $this->addMethodFromGenerator($method);
 549             } else {
 550                 if (is_string($method)) {
 551                     $this->addMethod($method);
 552                 } elseif (is_array($method)) {
 553                     call_user_func_array(array($this, 'addMethod'), $method);
 554                 }
 555             }
 556         }
 557
 558         return $this;
 559     }
 560
 561     /**
 562      * Add Method from scalars
 563      *
 564      * @param  string $name
 565      * @param  array $parameters
 566      * @param  int $flags
 567      * @param  string $body
 568      * @param  string $docBlock
 569      * @throws Exception\InvalidArgumentException
 570      * @return ClassGenerator
 571      */
 572     public function addMethod($name = null, array $parameters = array(), $flags = MethodGenerator::FLAG_PUBLIC,
 573                               $body = null, $docBlock = null)
 574     {
 575         if (!is_string($name)) {
 576             throw new Exception\InvalidArgumentException(sprintf(
 577                 '%s expects string for name',
 578                 __METHOD__
 579             ));
 580         }
 581
 582         return $this->addMethodFromGenerator(new MethodGenerator($name, $parameters, $flags, $body, $docBlock));
 583     }
 584
 585     /**
 586      * Add Method from MethodGenerator
 587      *
 588      * @param  MethodGenerator                    $method
 589      * @throws Exception\InvalidArgumentException
 590      * @return ClassGenerator
 591      */
 592     public function addMethodFromGenerator(MethodGenerator $method)
 593     {
 594         $methodName = $method->getName();
 595
 596         if (isset($this->methods[$methodName])) {
 597             throw new Exception\InvalidArgumentException(sprintf(
 598                 'A method by name %s already exists in this class.',
 599                 $methodName
 600             ));
 601         }
 602
 603         $this->methods[$methodName] = $method;
 604         return $this;
 605     }
 606
 607     /**
 608      * @return MethodGenerator[]
 609      */
 610     public function getMethods()
 611     {
 612         return $this->methods;
 613     }
 614
 615     /**
 616      * @param  string $methodName
 617      * @return MethodGenerator|false
 618      */
 619     public function getMethod($methodName)
 620     {
 621         foreach ($this->methods as $method) {
 622             if ($method->getName() == $methodName) {
 623                 return $method;
 624             }
 625         }
 626
 627         return false;
 628     }
 629
 630     /**
 631      * @param  string $methodName
 632      * @return ClassGenerator
 633      */
 634     public function removeMethod($methodName)
 635     {
 636         foreach ($this->methods as $key => $method) {
 637             if ($method->getName() == $methodName) {
 638                 unset($this->methods[$key]);
 639                 break;
 640             }
 641         }
 642
 643         return $this;
 644     }
 645
 646     /**
 647      * @param  string $methodName
 648      * @return bool
 649      */
 650     public function hasMethod($methodName)
 651     {
 652         return isset($this->methods[$methodName]);
 653     }
 654
 655     /**
 656      * @return bool
 657      */
 658     public function isSourceDirty()
 659     {
 660         if (($docBlock = $this->getDocBlock()) && $docBlock->isSourceDirty()) {
 661             return true;
 662         }
 663
 664         foreach ($this->getProperties() as $property) {
 665             if ($property->isSourceDirty()) {
 666                 return true;
 667             }
 668         }
 669
 670         foreach ($this->getMethods() as $method) {
 671             if ($method->isSourceDirty()) {
 672                 return true;
 673             }
 674         }
 675
 676         return parent::isSourceDirty();
 677     }
 678
 679     /**
 680      * @return string
 681      */
 682     public function generate()
 683     {
 684         if (!$this->isSourceDirty()) {
 685             $output = $this->getSourceContent();
 686             if (!empty($output)) {
 687                 return $output;
 688             }
 689         }
 690
 691         $output = '';
 692
 693         if (null !== ($namespace = $this->getNamespaceName())) {
 694             $output .= 'namespace ' . $namespace . ';' . self::LINE_FEED . self::LINE_FEED;
 695         }
 696
 697         $uses = $this->getUses();
 698         if (!empty($uses)) {
 699             foreach ($uses as $use) {
 700                 $output .= 'use ' . $use . ';' . self::LINE_FEED;
 701             }
 702             $output .= self::LINE_FEED;
 703         }
 704
 705         if (null !== ($docBlock = $this->getDocBlock())) {
 706             $docBlock->setIndentation('');
 707             $output .= $docBlock->generate();
 708         }
 709
 710         if ($this->isAbstract()) {
 711             $output .= 'abstract ';
 712         }
 713
 714         $output .= 'class ' . $this->getName();
 715
 716         if (!empty($this->extendedClass)) {
 717             $output .= ' extends ' . $this->extendedClass;
 718         }
 719
 720         $implemented = $this->getImplementedInterfaces();
 721         if (!empty($implemented)) {
 722             $output .= ' implements ' . implode(', ', $implemented);
 723         }
 724
 725         $output .= self::LINE_FEED . '{' . self::LINE_FEED . self::LINE_FEED;
 726
 727         $properties = $this->getProperties();
 728         if (!empty($properties)) {
 729             foreach ($properties as $property) {
 730                 $output .= $property->generate() . self::LINE_FEED . self::LINE_FEED;
 731             }
 732         }
 733
 734         $methods = $this->getMethods();
 735         if (!empty($methods)) {
 736             foreach ($methods as $method) {
 737                 $output .= $method->generate() . self::LINE_FEED;
 738             }
 739         }
 740
 741         $output .= self::LINE_FEED . '}' . self::LINE_FEED;
 742
 743         return $output;
 744     }
 745 }