[READ ONLY] Ovos Mod

composer.json

@@ -1,5 +1,8 @@
 {
-    "name": "php-di/php-di",
+    "name": "ovos/php-di",
+    "replace": {
+        "php-di/php-di": "^6.0.8"
+    },
     "type": "library",
     "description": "The dependency injection container for humans",
     "keywords": ["di", "dependency injection", "container", "ioc", "psr-11", "psr11", "container-interop"],
@@ -45,5 +48,10 @@
     "suggest": {
         "doctrine/annotations": "Install it if you want to use annotations (version ~1.2)",
         "ocramius/proxy-manager": "Install it if you want to use lazy injection (version ~2.0)"
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-mod": "6.x-dev"
+        }
     }
 }

phpstan.neon

@@ -10,5 +10,6 @@ parameters:
     ignoreErrors:
         - '#Access to undefined constant DI\\CompiledContainer::METHOD_MAPPING.#'
         - '#Function apcu_.* not found.#'
+        - '#PHPDoc tag @throws with type Psr\\Container\\ContainerExceptionInterface is not subtype of Throwable#'
     reportUnmatchedIgnoredErrors: false
     inferPrivatePropertyTypeFromConstructor: true

src/CompiledContainer.php

@@ -16,6 +16,7 @@
 use Invoker\ParameterResolver\DefaultValueResolver;
 use Invoker\ParameterResolver\NumericArrayResolver;
 use Invoker\ParameterResolver\ResolverChain;
+use Psr\Container\NotFoundExceptionInterface;
 
 /**
  * Compiled version of the dependency injection container.
@@ -120,4 +121,42 @@ protected function resolveFactory($callable, $entryName, array $extraParameters
             throw new InvalidDefinition("Entry \"$entryName\" cannot be resolved: " . $e->getMessage());
         }
     }
+
+    /**
+     * Resolve a placeholder in string definition
+     * - wrap possible NotFound exception to conform to the one from StringDefinition::resolveExpression.
+     */
+    protected function resolveStringPlaceholder($placeholder, $entryName)
+    {
+        try {
+            return $this->delegateContainer->get($placeholder);
+        } catch (NotFoundExceptionInterface $e) {
+            throw new DependencyException(sprintf(
+                "Error while parsing string expression for entry '%s': %s",
+                $entryName,
+                $e->getMessage()
+            ), 0, $e);
+        }
+    }
+
+    /**
+     * Resolve ServiceLocator for given subscriber class (based on \DI\Definition\ServiceLocatorDefinition::resolve).
+     *
+     * @param string $requestingName class name of a subscriber, implementing ServiceSubscriberInterface
+     * @param string $repositoryClass ServiceLocatorRepository
+     * @return ServiceLocator
+     * @throws ServiceSubscriberException
+     */
+    protected function resolveServiceLocator($requestingName, $repositoryClass)
+    {
+        if (!method_exists($requestingName, 'getSubscribedServices')) {
+            throw new ServiceSubscriberException(sprintf('The class %s does not implement ServiceSubscriberInterface.', $requestingName));
+        }
+
+        /** @var ServiceLocatorRepository $repository */
+        $repository = $this->delegateContainer->get($repositoryClass);
+        $services = $requestingName::getSubscribedServices();
+
+        return $repository->create($requestingName, $services);
+    }
 }

src/Compiler/Compiler.php

@@ -5,6 +5,7 @@
 namespace DI\Compiler;
 
 use function chmod;
+use DI\Container;
 use DI\Definition\ArrayDefinition;
 use DI\Definition\DecoratorDefinition;
 use DI\Definition\Definition;
@@ -22,6 +23,8 @@
 use function file_put_contents;
 use InvalidArgumentException;
 use Opis\Closure\SerializableClosure;
+use ReflectionFunction;
+use ReflectionFunctionAbstract;
 use function rename;
 use function sprintf;
 use function tempnam;
@@ -227,6 +230,13 @@ private function compileDefinition(string $entryName, Definition $definition) :
                 $code = 'return ' . $this->compileValue($value) . ';';
                 break;
             case $definition instanceof Reference:
+                if ($definition->isServiceLocatorEntry()) {
+                    $requestingEntry = $definition->getRequestingName();
+                    $serviceLocatorDefinition = $definition->getServiceLocatorDefinition();
+                    $code = 'return $this->resolveServiceLocator(' . $this->compileValue($requestingEntry) . ', ' . $this->compileValue($serviceLocatorDefinition::$serviceLocatorRepositoryClass) . ');';
+                    break;
+                }
+
                 $targetEntryName = $definition->getTargetEntryName();
                 $code = 'return $this->delegateContainer->get(' . $this->compileValue($targetEntryName) . ');';
                 // If this method is not yet compiled we store it for compilation
@@ -235,9 +245,12 @@ private function compileDefinition(string $entryName, Definition $definition) :
                 }
                 break;
             case $definition instanceof StringDefinition:
-                $entryName = $this->compileValue($definition->getName());
-                $expression = $this->compileValue($definition->getExpression());
-                $code = 'return \DI\Definition\StringDefinition::resolveExpression(' . $entryName . ', ' . $expression . ', $this->delegateContainer);';
+                $expression = $definition->getExpression();
+                $callback = function (array $matches) use ($definition) {
+                    return '\'.$this->resolveStringPlaceholder(' . $this->compileValue($matches[1]) . ', ' . $this->compileValue($definition->getName()) . ').\'';
+                };
+                $value = preg_replace_callback('#\{([^\{\}]+)\}#', $callback, $expression);
+                $code = 'return \'' . $value . '\';';
                 break;
             case $definition instanceof EnvironmentVariableDefinition:
                 $variableName = $this->compileValue($definition->getVariableName());
@@ -297,6 +310,35 @@ private function compileDefinition(string $entryName, Definition $definition) :
                     ));
                 }
 
+                if ($value instanceof \Closure) {
+                    $reflection = new ReflectionFunction($value);
+                    $requestedEntry = new RequestedEntryHolder($entryName);
+                    $parametersByClassName = [
+                        'DI\Factory\RequestedEntry' => $requestedEntry,
+                    ];
+                    // default non-typehinted parameters
+                    $defaultParameters = [new Reference(Container::class), $requestedEntry];
+
+                    $resolvedParameters = $this->resolveFactoryParameters(
+                        $reflection,
+                        $definition->getParameters(),
+                        $parametersByClassName,
+                        $defaultParameters
+                    );
+
+                    $definitionParameters = array_map(function ($value) {
+                        return $this->compileValue($value);
+                    }, $resolvedParameters);
+
+                    $code = sprintf(
+                        'return (%s)(%s);',
+                        $this->compileValue($value),
+                        implode(', ', $definitionParameters)
+                    );
+                    break;
+                }
+
+                // todo optimize other (non-closure) factories
                 $definitionParameters = '';
                 if (!empty($definition->getParameters())) {
                     $definitionParameters = ', ' . $this->compileValue($definition->getParameters());
@@ -328,6 +370,11 @@ public function compileValue($value) : string
             throw new InvalidDefinition($errorMessage);
         }
 
+        // one step ahead to skip CompiledContainer->resolveFactory
+        if ($value instanceof RequestedEntryHolder) {
+            return 'new DI\Compiler\RequestedEntryHolder(\'' . $value->getName() . '\')';
+        }
+
         if ($value instanceof Definition) {
             // Give it an arbitrary unique name
             $subEntryName = 'subEntry' . (++$this->subEntryCounter);
@@ -386,6 +433,10 @@ private function isCompilable($value)
         if ($value instanceof \Closure) {
             return true;
         }
+        // added for skipping CompiledContainer->resolveFactory - there is a special case for this in compileValue method
+        if ($value instanceof RequestedEntryHolder) {
+            return true;
+        }
         if (is_object($value)) {
             return 'An object was found but objects cannot be compiled';
         }
@@ -420,4 +471,39 @@ private function compileClosure(\Closure $closure) : string
 
         return $code;
     }
+
+    public function resolveFactoryParameters(
+        ReflectionFunctionAbstract $reflection,
+        array $definitionParameters = [],
+        array $parametersByClassName = [],
+        array $defaultParameters = []
+    ) {
+        $resolvedParameters = [];
+        $parameters = $reflection->getParameters();
+
+        foreach ($parameters as $index => $parameter) {
+            $name = $parameter->getName();
+            if (array_key_exists($name, $definitionParameters)) {
+                $resolvedParameters[$index] = $definitionParameters[$name];
+                continue;
+            }
+
+            $parameterClass = $parameter->getClass();
+            if (!$parameterClass) {
+                if (array_key_exists($index, $defaultParameters)) {
+                    // take default parameters, when no typehint
+                    $resolvedParameters[$index] = $defaultParameters[$index];
+                }
+                continue;
+            }
+
+            if (isset($parametersByClassName[$parameterClass->name])) {
+                $resolvedParameters[$index] = $parametersByClassName[$parameterClass->name];
+            } else {
+                $resolvedParameters[$index] = new Reference($parameterClass->name);
+            }
+        }
+
+        return $resolvedParameters;
+    }
 }

src/ContainerBuilder.php

@@ -8,6 +8,7 @@
 use DI\Definition\Source\AnnotationBasedAutowiring;
 use DI\Definition\Source\DefinitionArray;
 use DI\Definition\Source\DefinitionFile;
+use DI\Definition\Source\DefinitionGlob;
 use DI\Definition\Source\DefinitionSource;
 use DI\Definition\Source\NoAutowiring;
 use DI\Definition\Source\ReflectionBasedAutowiring;
@@ -56,6 +57,11 @@ class ContainerBuilder
      */
     private $useAnnotations = false;
 
+    /**
+     * @var int
+     */
+    private $annotationsFlags = 0;
+
     /**
      * @var bool
      */
@@ -131,7 +137,7 @@ public function build()
         $sources = array_reverse($this->definitionSources);
 
         if ($this->useAnnotations) {
-            $autowiring = new AnnotationBasedAutowiring($this->ignorePhpDocErrors);
+            $autowiring = new AnnotationBasedAutowiring($this->ignorePhpDocErrors, $this->annotationsFlags);
             $sources[] = $autowiring;
         } elseif ($this->useAutowiring) {
             $autowiring = new ReflectionBasedAutowiring;
@@ -146,6 +152,8 @@ public function build()
                 return new DefinitionFile($definitions, $autowiring);
             } elseif (is_array($definitions)) {
                 return new DefinitionArray($definitions, $autowiring);
+            } elseif ($definitions instanceof DefinitionGlob) {
+                $definitions->setAutowiring($autowiring);
             }
 
             return $definitions;
@@ -155,10 +163,8 @@ public function build()
         // Mutable definition source
         $source->setMutableDefinitionSource(new DefinitionArray([], $autowiring));
 
-        if ($this->sourceCache) {
-            if (!SourceCache::isSupported()) {
-                throw new \Exception('APCu is not enabled, PHP-DI cannot use it as a cache');
-            }
+        // use cache if isSupported check passes, otherwise proceed without cache and do not throw an exception
+        if ($this->sourceCache && SourceCache::isSupported()) {
             // Wrap the source with the cache decorator
             $source = new SourceCache($source, $this->sourceCacheNamespace);
         }
@@ -244,11 +250,12 @@ public function useAutowiring(bool $bool) : self
      *
      * @return $this
      */
-    public function useAnnotations(bool $bool) : self
+    public function useAnnotations(bool $bool, int $flags = 0) : self
     {
         $this->ensureNotLocked();
 
         $this->useAnnotations = $bool;
+        $this->annotationsFlags = $flags;
 
         return $this;
     }

src/Definition/ArrayDefinition.php

@@ -50,7 +50,7 @@ public function replaceNestedDefinitions(callable $replacer)
 
     public function __toString()
     {
-        $str = '[' . PHP_EOL;
+        $str = '[' . \PHP_EOL;
 
         foreach ($this->values as $key => $value) {
             if (is_string($key)) {
@@ -60,12 +60,12 @@ public function __toString()
             $str .= '    ' . $key . ' => ';
 
             if ($value instanceof Definition) {
-                $str .= str_replace(PHP_EOL, PHP_EOL . '    ', (string) $value);
+                $str .= str_replace(\PHP_EOL, \PHP_EOL . '    ', (string) $value);
             } else {
                 $str .= var_export($value, true);
             }
 
-            $str .= ',' . PHP_EOL;
+            $str .= ',' . \PHP_EOL;
         }
 
         return $str . ']';

src/Definition/AutowireDefinition.php

@@ -9,4 +9,25 @@
  */
 class AutowireDefinition extends ObjectDefinition
 {
+    /**
+     * @var bool|null
+     */
+    protected $useAnnotations;
+
+    /**
+     * Enable/disable reading annotations for this definition, regardless of a container configuration.
+     */
+    public function useAnnotations(bool $flag = true)
+    {
+        $this->useAnnotations = $flag;
+    }
+
+    /**
+     * Returns boolean if the useAnnotation flag was explicitly set, otherwise null.
+     * @return bool|null
+     */
+    public function isUsingAnnotations()
+    {
+        return $this->useAnnotations;
+    }
 }

src/Definition/Dumper/ObjectDefinitionDumper.php

@@ -35,7 +35,7 @@ public function dump(ObjectDefinition $definition) : string
         $str = sprintf('    class = %s%s', $warning, $className);
 
         // Lazy
-        $str .= PHP_EOL . '    lazy = ' . var_export($definition->isLazy(), true);
+        $str .= \PHP_EOL . '    lazy = ' . var_export($definition->isLazy(), true);
 
         if ($classExist) {
             // Constructor
@@ -48,7 +48,7 @@ public function dump(ObjectDefinition $definition) : string
             $str .= $this->dumpMethods($className, $definition);
         }
 
-        return sprintf('Object (' . PHP_EOL . '%s' . PHP_EOL . ')', $str);
+        return sprintf('Object (' . \PHP_EOL . '%s' . \PHP_EOL . ')', $str);
     }
 
     private function dumpConstructor(string $className, ObjectDefinition $definition) : string
@@ -60,7 +60,7 @@ private function dumpConstructor(string $className, ObjectDefinition $definition
         if ($constructorInjection !== null) {
             $parameters = $this->dumpMethodParameters($className, $constructorInjection);
 
-            $str .= sprintf(PHP_EOL . '    __construct(' . PHP_EOL . '        %s' . PHP_EOL . '    )', $parameters);
+            $str .= sprintf(\PHP_EOL . '    __construct(' . \PHP_EOL . '        %s' . \PHP_EOL . '    )', $parameters);
         }
 
         return $str;
@@ -74,7 +74,7 @@ private function dumpProperties(ObjectDefinition $definition) : string
             $value = $propertyInjection->getValue();
             $valueStr = $value instanceof Definition ? (string) $value : var_export($value, true);
 
-            $str .= sprintf(PHP_EOL . '    $%s = %s', $propertyInjection->getPropertyName(), $valueStr);
+            $str .= sprintf(\PHP_EOL . '    $%s = %s', $propertyInjection->getPropertyName(), $valueStr);
         }
 
         return $str;
@@ -87,7 +87,7 @@ private function dumpMethods(string $className, ObjectDefinition $definition) :
         foreach ($definition->getMethodInjections() as $methodInjection) {
             $parameters = $this->dumpMethodParameters($className, $methodInjection);
 
-            $str .= sprintf(PHP_EOL . '    %s(' . PHP_EOL . '        %s' . PHP_EOL . '    )', $methodInjection->getMethodName(), $parameters);
+            $str .= sprintf(\PHP_EOL . '    %s(' . \PHP_EOL . '        %s' . \PHP_EOL . '    )', $methodInjection->getMethodName(), $parameters);
         }
 
         return $str;
@@ -130,6 +130,6 @@ private function dumpMethodParameters(string $className, MethodInjection $method
             $args[] = sprintf('$%s = #UNDEFINED#', $parameter->getName());
         }
 
-        return implode(PHP_EOL . '        ', $args);
+        return implode(\PHP_EOL . '        ', $args);
     }
 }