interface/modules/zend_modules/library/Zend/Code/Generator/MethodGenerator.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\MethodReflection;
  13
  14 class MethodGenerator extends AbstractMemberGenerator
  15 {
  16     /**
  17      * @var DocBlockGenerator
  18      */
  19     protected $docBlock = null;
  20
  21     /**
  22      * @var ParameterGenerator[]
  23      */
  24     protected $parameters = array();
  25
  26     /**
  27      * @var string
  28      */
  29     protected $body = null;
  30
  31     /**
  32      * @param  MethodReflection $reflectionMethod
  33      * @return MethodGenerator
  34      */
  35     public static function fromReflection(MethodReflection $reflectionMethod)
  36     {
  37         $method = new static();
  38
  39         $method->setSourceContent($reflectionMethod->getContents(false));
  40         $method->setSourceDirty(false);
  41
  42         if ($reflectionMethod->getDocComment() != '') {
  43             $method->setDocBlock(DocBlockGenerator::fromReflection($reflectionMethod->getDocBlock()));
  44         }
  45
  46         $method->setFinal($reflectionMethod->isFinal());
  47
  48         if ($reflectionMethod->isPrivate()) {
  49             $method->setVisibility(self::VISIBILITY_PRIVATE);
  50         } elseif ($reflectionMethod->isProtected()) {
  51             $method->setVisibility(self::VISIBILITY_PROTECTED);
  52         } else {
  53             $method->setVisibility(self::VISIBILITY_PUBLIC);
  54         }
  55
  56         $method->setStatic($reflectionMethod->isStatic());
  57
  58         $method->setName($reflectionMethod->getName());
  59
  60         foreach ($reflectionMethod->getParameters() as $reflectionParameter) {
  61             $method->setParameter(ParameterGenerator::fromReflection($reflectionParameter));
  62         }
  63
  64         $method->setBody($reflectionMethod->getBody());
  65
  66         return $method;
  67     }
  68
  69     /**
  70      * Generate from array
  71      *
  72      * @configkey name           string        [required] Class Name
  73      * @configkey docblock       string        The docblock information
  74      * @configkey flags          int           Flags, one of MethodGenerator::FLAG_ABSTRACT MethodGenerator::FLAG_FINAL
  75      * @configkey parameters     string        Class which this class is extending
  76      * @configkey body           string
  77      * @configkey abstract       bool
  78      * @configkey final          bool
  79      * @configkey static         bool
  80      * @configkey visibility     string
  81      *
  82      * @throws Exception\InvalidArgumentException
  83      * @param  array $array
  84      * @return MethodGenerator
  85      */
  86     public static function fromArray(array $array)
  87     {
  88         if (!isset($array['name'])) {
  89             throw new Exception\InvalidArgumentException(
  90                 'Method generator requires that a name is provided for this object'
  91             );
  92         }
  93
  94         $method = new static($array['name']);
  95         foreach ($array as $name => $value) {
  96             // normalize key
  97             switch (strtolower(str_replace(array('.', '-', '_'), '', $name))) {
  98                 case 'docblock':
  99                     $docBlock = ($value instanceof DocBlockGenerator) ? $value : DocBlockGenerator::fromArray($value);
 100                     $method->setDocBlock($docBlock);
 101                     break;
 102                 case 'flags':
 103                     $method->setFlags($value);
 104                     break;
 105                 case 'parameters':
 106                     $method->setParameters($value);
 107                     break;
 108                 case 'body':
 109                     $method->setBody($value);
 110                     break;
 111                 case 'abstract':
 112                     $method->setAbstract($value);
 113                     break;
 114                 case 'final':
 115                     $method->setFinal($value);
 116                     break;
 117                 case 'static':
 118                     $method->setStatic($value);
 119                     break;
 120                 case 'visibility':
 121                     $method->setVisibility($value);
 122                     break;
 123             }
 124         }
 125
 126         return $method;
 127     }
 128
 129     /**
 130      * @param  string $name
 131      * @param  array $parameters
 132      * @param  int|array $flags
 133      * @param  string $body
 134      * @param  DocBlockGenerator|string $docBlock
 135      */
 136     public function __construct($name = null, array $parameters = array(), $flags = self::FLAG_PUBLIC, $body = null,
 137                                 $docBlock = null)
 138     {
 139         if ($name) {
 140             $this->setName($name);
 141         }
 142         if ($parameters) {
 143             $this->setParameters($parameters);
 144         }
 145         if ($flags !== self::FLAG_PUBLIC) {
 146             $this->setFlags($flags);
 147         }
 148         if ($body) {
 149             $this->setBody($body);
 150         }
 151         if ($docBlock) {
 152             $this->setDocBlock($docBlock);
 153         }
 154     }
 155
 156     /**
 157      * @param  array $parameters
 158      * @return MethodGenerator
 159      */
 160     public function setParameters(array $parameters)
 161     {
 162         foreach ($parameters as $parameter) {
 163             $this->setParameter($parameter);
 164         }
 165
 166         return $this;
 167     }
 168
 169     /**
 170      * @param  ParameterGenerator|string $parameter
 171      * @throws Exception\InvalidArgumentException
 172      * @return MethodGenerator
 173      */
 174     public function setParameter($parameter)
 175     {
 176         if (is_string($parameter)) {
 177             $parameter = new ParameterGenerator($parameter);
 178         } elseif (!$parameter instanceof ParameterGenerator) {
 179             throw new Exception\InvalidArgumentException(sprintf(
 180                 '%s is expecting either a string, array or an instance of %s\ParameterGenerator',
 181                 __METHOD__,
 182                 __NAMESPACE__
 183             ));
 184         }
 185
 186         $parameterName = $parameter->getName();
 187
 188         $this->parameters[$parameterName] = $parameter;
 189
 190         return $this;
 191     }
 192
 193     /**
 194      * @return ParameterGenerator[]
 195      */
 196     public function getParameters()
 197     {
 198         return $this->parameters;
 199     }
 200
 201     /**
 202      * @param  string $body
 203      * @return MethodGenerator
 204      */
 205     public function setBody($body)
 206     {
 207         $this->body = $body;
 208         return $this;
 209     }
 210
 211     /**
 212      * @return string
 213      */
 214     public function getBody()
 215     {
 216         return $this->body;
 217     }
 218
 219     /**
 220      * @return string
 221      */
 222     public function generate()
 223     {
 224         $output = '';
 225
 226         $indent = $this->getIndentation();
 227
 228         if (($docBlock = $this->getDocBlock()) !== null) {
 229             $docBlock->setIndentation($indent);
 230             $output .= $docBlock->generate();
 231         }
 232
 233         $output .= $indent;
 234
 235         if ($this->isAbstract()) {
 236             $output .= 'abstract ';
 237         } else {
 238             $output .= (($this->isFinal()) ? 'final ' : '');
 239         }
 240
 241         $output .= $this->getVisibility()
 242             . (($this->isStatic()) ? ' static' : '')
 243             . ' function ' . $this->getName() . '(';
 244
 245         $parameters = $this->getParameters();
 246         if (!empty($parameters)) {
 247             foreach ($parameters as $parameter) {
 248                 $parameterOutput[] = $parameter->generate();
 249             }
 250
 251             $output .= implode(', ', $parameterOutput);
 252         }
 253
 254         $output .= ')';
 255
 256         if ($this->isAbstract()) {
 257             return $output . ';';
 258         }
 259
 260         $output .= self::LINE_FEED . $indent . '{' . self::LINE_FEED;
 261
 262         if ($this->body) {
 263             $output .= preg_replace('#^(.+?)$#m', $indent . $indent . '$1', trim($this->body))
 264                 . self::LINE_FEED;
 265         }
 266
 267         $output .= $indent . '}' . self::LINE_FEED;
 268
 269         return $output;
 270     }
 271
 272     public function __toString()
 273     {
 274         return $this->generate();
 275     }
 276 }