interface/modules/zend_modules/library/Zend/Code/Generator/ValueGenerator.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\Stdlib\ArrayObject;
  13
  14 class ValueGenerator extends AbstractGenerator
  15 {
  16     /**#@+
  17      * Constant values
  18      */
  19     const TYPE_AUTO     = 'auto';
  20     const TYPE_BOOLEAN  = 'boolean';
  21     const TYPE_BOOL     = 'bool';
  22     const TYPE_NUMBER   = 'number';
  23     const TYPE_INTEGER  = 'integer';
  24     const TYPE_INT      = 'int';
  25     const TYPE_FLOAT    = 'float';
  26     const TYPE_DOUBLE   = 'double';
  27     const TYPE_STRING   = 'string';
  28     const TYPE_ARRAY    = 'array';
  29     const TYPE_CONSTANT = 'constant';
  30     const TYPE_NULL     = 'null';
  31     const TYPE_OBJECT   = 'object';
  32     const TYPE_OTHER    = 'other';
  33     /**#@-*/
  34
  35     const OUTPUT_MULTIPLE_LINE = 'multipleLine';
  36     const OUTPUT_SINGLE_LINE   = 'singleLine';
  37
  38     /**
  39      * @var mixed
  40      */
  41     protected $value = null;
  42
  43     /**
  44      * @var string
  45      */
  46     protected $type = self::TYPE_AUTO;
  47
  48     /**
  49      * @var int
  50      */
  51     protected $arrayDepth = 1;
  52
  53     /**
  54      * @var string
  55      */
  56     protected $outputMode = self::OUTPUT_MULTIPLE_LINE;
  57
  58     /**
  59      * @var array
  60      */
  61     protected $allowedTypes = null;
  62     /**
  63      * Autodetectable constants
  64      * @var ArrayObject
  65      */
  66     protected $constants = null;
  67
  68     /**
  69      * @param mixed       $value
  70      * @param string      $type
  71      * @param string      $outputMode
  72      * @param ArrayObject $constants
  73      */
  74     public function __construct($value = null, $type = self::TYPE_AUTO, $outputMode = self::OUTPUT_MULTIPLE_LINE, ArrayObject $constants = null)
  75     {
  76         if ($value !== null) { // strict check is important here if $type = AUTO
  77             $this->setValue($value);
  78         }
  79         if ($type !== self::TYPE_AUTO) {
  80             $this->setType($type);
  81         }
  82         if ($outputMode !== self::OUTPUT_MULTIPLE_LINE) {
  83             $this->setOutputMode($outputMode);
  84         }
  85         if ($constants !== null) {
  86             $this->constants = $constants;
  87         } else {
  88             $this->constants = new ArrayObject();
  89         }
  90
  91     }
  92
  93     /**
  94      * Init constant list by defined and magic constants
  95      */
  96     public function initEnvironmentConstants()
  97     {
  98         $constants   = array(
  99             '__DIR__',
 100             '__FILE__',
 101             '__LINE__',
 102             '__CLASS__',
 103             '__TRAIT__',
 104             '__METHOD__',
 105             '__FUNCTION__',
 106             '__NAMESPACE__',
 107             '::'
 108         );
 109         $constants = array_merge($constants, array_keys(get_defined_constants()), $this->constants->getArrayCopy());
 110         $this->constants->exchangeArray($constants);
 111     }
 112
 113     /**
 114      * Add constant to list
 115      *
 116      * @param string $constant
 117      *
 118      * @return $this
 119      */
 120     public function addConstant($constant)
 121     {
 122         $this->constants->append($constant);
 123
 124         return $this;
 125     }
 126
 127     /**
 128      * Delete constant from constant list
 129      *
 130      * @param string $constant
 131      *
 132      * @return bool
 133      */
 134     public function deleteConstant($constant)
 135     {
 136         if (($index = array_search($constant, $this->constants->getArrayCopy())) !== false) {
 137             $this->constants->offsetUnset($index);
 138         }
 139
 140         return $index !== false;
 141     }
 142
 143     /**
 144      * Return constant list
 145      *
 146      * @return ArrayObject
 147      */
 148     public function getConstants()
 149     {
 150         return $this->constants;
 151     }
 152
 153     /**
 154      * @return bool
 155      */
 156     public function isValidConstantType()
 157     {
 158         if ($this->type == self::TYPE_AUTO) {
 159             $type = $this->getAutoDeterminedType($this->value);
 160         } else {
 161             $type = $this->type;
 162         }
 163
 164         // valid types for constants
 165         $scalarTypes = array(
 166             self::TYPE_BOOLEAN,
 167             self::TYPE_BOOL,
 168             self::TYPE_NUMBER,
 169             self::TYPE_INTEGER,
 170             self::TYPE_INT,
 171             self::TYPE_FLOAT,
 172             self::TYPE_DOUBLE,
 173             self::TYPE_STRING,
 174             self::TYPE_CONSTANT,
 175             self::TYPE_NULL
 176         );
 177
 178         return in_array($type, $scalarTypes);
 179     }
 180
 181     /**
 182      * @param  mixed $value
 183      * @return ValueGenerator
 184      */
 185     public function setValue($value)
 186     {
 187         $this->value = $value;
 188         return $this;
 189     }
 190
 191     /**
 192      * @return mixed
 193      */
 194     public function getValue()
 195     {
 196         return $this->value;
 197     }
 198
 199     /**
 200      * @param  string $type
 201      * @return ValueGenerator
 202      */
 203     public function setType($type)
 204     {
 205         $this->type = (string) $type;
 206         return $this;
 207     }
 208
 209     /**
 210      * @return string
 211      */
 212     public function getType()
 213     {
 214         return $this->type;
 215     }
 216
 217     /**
 218      * @param  int $arrayDepth
 219      * @return ValueGenerator
 220      */
 221     public function setArrayDepth($arrayDepth)
 222     {
 223         $this->arrayDepth = (int) $arrayDepth;
 224         return $this;
 225     }
 226
 227     /**
 228      * @return int
 229      */
 230     public function getArrayDepth()
 231     {
 232         return $this->arrayDepth;
 233     }
 234
 235     /**
 236      * @param  string $type
 237      * @return string
 238      */
 239     protected function getValidatedType($type)
 240     {
 241         $types = array(
 242             self::TYPE_AUTO,
 243             self::TYPE_BOOLEAN,
 244             self::TYPE_BOOL,
 245             self::TYPE_NUMBER,
 246             self::TYPE_INTEGER,
 247             self::TYPE_INT,
 248             self::TYPE_FLOAT,
 249             self::TYPE_DOUBLE,
 250             self::TYPE_STRING,
 251             self::TYPE_ARRAY,
 252             self::TYPE_CONSTANT,
 253             self::TYPE_NULL,
 254             self::TYPE_OBJECT,
 255             self::TYPE_OTHER
 256         );
 257
 258         if (in_array($type, $types)) {
 259             return $type;
 260         }
 261
 262         return self::TYPE_AUTO;
 263     }
 264
 265     /**
 266      * @param  mixed $value
 267      * @return string
 268      */
 269     public function getAutoDeterminedType($value)
 270     {
 271         switch (gettype($value)) {
 272             case 'boolean':
 273                 return self::TYPE_BOOLEAN;
 274             case 'string':
 275                 foreach ($this->constants as $constant) {
 276                     if (strpos($value, $constant) !== false) {
 277                         return self::TYPE_CONSTANT;
 278                     }
 279                 }
 280                 return self::TYPE_STRING;
 281             case 'double':
 282             case 'float':
 283             case 'integer':
 284                 return self::TYPE_NUMBER;
 285             case 'array':
 286                 return self::TYPE_ARRAY;
 287             case 'NULL':
 288                 return self::TYPE_NULL;
 289             case 'object':
 290             case 'resource':
 291             case 'unknown type':
 292             default:
 293                 return self::TYPE_OTHER;
 294         }
 295     }
 296
 297     /**
 298      * @throws Exception\RuntimeException
 299      * @return string
 300      */
 301     public function generate()
 302     {
 303         $type = $this->type;
 304
 305         if ($type != self::TYPE_AUTO) {
 306             $type = $this->getValidatedType($type);
 307         }
 308
 309         $value = $this->value;
 310
 311         if ($type == self::TYPE_AUTO) {
 312             $type = $this->getAutoDeterminedType($value);
 313
 314             if ($type == self::TYPE_ARRAY) {
 315                 $rii = new \RecursiveIteratorIterator(
 316                     $it = new \RecursiveArrayIterator($value),
 317                     \RecursiveIteratorIterator::SELF_FIRST
 318                 );
 319                 foreach ($rii as $curKey => $curValue) {
 320                     if (!$curValue instanceof ValueGenerator) {
 321                         $curValue = new self($curValue, self::TYPE_AUTO, self::OUTPUT_MULTIPLE_LINE, $this->getConstants());
 322                         $rii->getSubIterator()->offsetSet($curKey, $curValue);
 323                     }
 324                     $curValue->setArrayDepth($rii->getDepth());
 325                 }
 326                 $value = $rii->getSubIterator()->getArrayCopy();
 327             }
 328
 329         }
 330
 331         $output = '';
 332
 333         switch ($type) {
 334             case self::TYPE_BOOLEAN:
 335             case self::TYPE_BOOL:
 336                 $output .= ($value ? 'true' : 'false');
 337                 break;
 338             case self::TYPE_STRING:
 339                 $output .= self::escape($value);
 340                 break;
 341             case self::TYPE_NULL:
 342                 $output .= 'null';
 343                 break;
 344             case self::TYPE_NUMBER:
 345             case self::TYPE_INTEGER:
 346             case self::TYPE_INT:
 347             case self::TYPE_FLOAT:
 348             case self::TYPE_DOUBLE:
 349             case self::TYPE_CONSTANT:
 350                 $output .= $value;
 351                 break;
 352             case self::TYPE_ARRAY:
 353                 $output .= 'array(';
 354                 $curArrayMultiblock = false;
 355                 if (count($value) > 1) {
 356                     $curArrayMultiblock = true;
 357                     if ($this->outputMode == self::OUTPUT_MULTIPLE_LINE) {
 358                         $output .= self::LINE_FEED . str_repeat($this->indentation, $this->arrayDepth + 1);
 359                     }
 360                 }
 361                 $outputParts = array();
 362                 $noKeyIndex  = 0;
 363                 foreach ($value as $n => $v) {
 364                     /* @var $v ValueGenerator */
 365                     $v->setArrayDepth($this->arrayDepth + 1);
 366                     $partV = $v->generate();
 367                     $short = false;
 368                     if (is_int($n)) {
 369                         if ($n === $noKeyIndex) {
 370                             $short = true;
 371                             $noKeyIndex++;
 372                         } else {
 373                             $noKeyIndex = max($n + 1, $noKeyIndex);
 374                         }
 375                     }
 376
 377                     if ($short) {
 378                         $outputParts[] = $partV;
 379                     } else {
 380                         $outputParts[] = (is_int($n) ? $n : self::escape($n)) . ' => ' . $partV;
 381                     }
 382                 }
 383                 $padding = ($this->outputMode == self::OUTPUT_MULTIPLE_LINE)
 384                     ? self::LINE_FEED . str_repeat($this->indentation, $this->arrayDepth + 1)
 385                     : ' ';
 386                 $output .= implode(',' . $padding, $outputParts);
 387                 if ($curArrayMultiblock == true && $this->outputMode == self::OUTPUT_MULTIPLE_LINE) {
 388                     $output .= self::LINE_FEED . str_repeat($this->indentation, $this->arrayDepth + 1);
 389                 }
 390                 $output .= ')';
 391                 break;
 392             case self::TYPE_OTHER:
 393             default:
 394                 throw new Exception\RuntimeException(sprintf(
 395                                                          'Type "%s" is unknown or cannot be used as property default value.',
 396                                                          get_class($value)
 397                                                      ));
 398         }
 399
 400         return $output;
 401     }
 402
 403     /**
 404      * Quotes value for PHP code.
 405      *
 406      * @param  string $input Raw string.
 407      * @param  bool $quote Whether add surrounding quotes or not.
 408      * @return string PHP-ready code.
 409      */
 410     public static function escape($input, $quote = true)
 411     {
 412         $output = addcslashes($input, "'");
 413
 414         // adds quoting strings
 415         if ($quote) {
 416             $output = "'" . $output . "'";
 417         }
 418
 419         return $output;
 420     }
 421
 422     /**
 423      * @param  string $outputMode
 424      * @return ValueGenerator
 425      */
 426     public function setOutputMode($outputMode)
 427     {
 428         $this->outputMode = (string) $outputMode;
 429         return $this;
 430     }
 431
 432     /**
 433      * @return string
 434      */
 435     public function getOutputMode()
 436     {
 437         return $this->outputMode;
 438     }
 439
 440     public function __toString()
 441     {
 442         return $this->generate();
 443     }
 444 }