git.stricted.de - GitHub/WoltLab/WCF.git/blob

   1 <?php
   2 /**
   3  * PHP-DI
   4  *
   5  * @link      http://php-di.org/
   6  * @copyright Matthieu Napoli (http://mnapoli.fr/)
   7  * @license   http://www.opensource.org/licenses/mit-license.php MIT (see the LICENSE file)
   8  */
   9
  10 namespace DI\Definition\Dumper;
  11
  12 use DI\Definition\ObjectDefinition;
  13 use DI\Definition\ObjectDefinition\MethodInjection;
  14 use DI\Definition\Definition;
  15 use DI\Definition\EntryReference;
  16 use ReflectionException;
  17 use ReflectionMethod;
  18
  19 /**
  20  * Dumps object definitions.
  21  *
  22  * @since 4.1
  23  * @author Matthieu Napoli <matthieu@mnapoli.fr>
  24  */
  25 class ObjectDefinitionDumper implements DefinitionDumper
  26 {
  27     /**
  28      * {@inheritdoc}
  29      */
  30     public function dump(Definition $definition)
  31     {
  32         if (! $definition instanceof ObjectDefinition) {
  33             throw new \InvalidArgumentException(sprintf(
  34                 'This definition dumper is only compatible with ObjectDefinition objects, %s given',
  35                 get_class($definition)
  36             ));
  37         }
  38
  39         $className = $definition->getClassName();
  40         $classExist = class_exists($className) || interface_exists($className);
  41
  42         // Class
  43         if (! $classExist) {
  44             $warning = '#UNKNOWN# ';
  45         } else {
  46             $class = new \ReflectionClass($className);
  47             $warning = $class->isInstantiable() ? '' : '#NOT INSTANTIABLE# ';
  48         }
  49         $str = sprintf('    class = %s%s', $warning, $className);
  50
  51         // Scope
  52         $str .= PHP_EOL . "    scope = " . $definition->getScope();
  53
  54         // Lazy
  55         $str .= PHP_EOL . "    lazy = " . var_export($definition->isLazy(), true);
  56
  57         if ($classExist) {
  58             // Constructor
  59             $str .= $this->dumpConstructor($className, $definition);
  60
  61             // Properties
  62             $str .= $this->dumpProperties($definition);
  63
  64             // Methods
  65             $str .= $this->dumpMethods($className, $definition);
  66         }
  67
  68         return sprintf("Object (" . PHP_EOL . "%s" . PHP_EOL . ")", $str);
  69     }
  70
  71     private function dumpConstructor($className, ObjectDefinition $definition)
  72     {
  73         $str = '';
  74
  75         $constructorInjection = $definition->getConstructorInjection();
  76
  77         if ($constructorInjection !== null) {
  78             $parameters = $this->dumpMethodParameters($className, $constructorInjection);
  79
  80             $str .= sprintf(PHP_EOL . "    __construct(" . PHP_EOL . "        %s" . PHP_EOL . "    )", $parameters);
  81         }
  82
  83         return $str;
  84     }
  85
  86     private function dumpProperties(ObjectDefinition $definition)
  87     {
  88         $str = '';
  89
  90         foreach ($definition->getPropertyInjections() as $propertyInjection) {
  91             $value = $propertyInjection->getValue();
  92             if ($value instanceof EntryReference) {
  93                 $valueStr = sprintf('get(%s)', $value->getName());
  94             } else {
  95                 $valueStr = var_export($value, true);
  96             }
  97
  98             $str .= sprintf(PHP_EOL . "    $%s = %s", $propertyInjection->getPropertyName(), $valueStr);
  99         }
 100
 101         return $str;
 102     }
 103
 104     private function dumpMethods($className, ObjectDefinition $definition)
 105     {
 106         $str = '';
 107
 108         foreach ($definition->getMethodInjections() as $methodInjection) {
 109             $parameters = $this->dumpMethodParameters($className, $methodInjection);
 110
 111             $str .= sprintf(PHP_EOL . "    %s(" . PHP_EOL . "        %s" . PHP_EOL . "    )", $methodInjection->getMethodName(), $parameters);
 112         }
 113
 114         return $str;
 115     }
 116
 117     private function dumpMethodParameters($className, MethodInjection $methodInjection)
 118     {
 119         $methodReflection = new \ReflectionMethod($className, $methodInjection->getMethodName());
 120
 121         $args = [];
 122
 123         $definitionParameters = $methodInjection->getParameters();
 124
 125         foreach ($methodReflection->getParameters() as $index => $parameter) {
 126             if (array_key_exists($index, $definitionParameters)) {
 127                 $value = $definitionParameters[$index];
 128
 129                 if ($value instanceof EntryReference) {
 130                     $args[] = sprintf('$%s = get(%s)', $parameter->getName(), $value->getName());
 131                 } else {
 132                     $args[] = sprintf('$%s = %s', $parameter->getName(), var_export($value, true));
 133                 }
 134                 continue;
 135             }
 136
 137             // If the parameter is optional and wasn't specified, we take its default value
 138             if ($parameter->isOptional()) {
 139                 try {
 140                     $value = $parameter->getDefaultValue();
 141
 142                     $args[] = sprintf(
 143                         '$%s = (default value) %s',
 144                         $parameter->getName(),
 145                         var_export($value, true)
 146                     );
 147                     continue;
 148                 } catch (ReflectionException $e) {
 149                     // The default value can't be read through Reflection because it is a PHP internal class
 150                 }
 151             }
 152
 153             $args[] = sprintf('$%s = #UNDEFINED#', $parameter->getName());
 154         }
 155
 156         return implode(PHP_EOL . '        ', $args);
 157     }
 158 }