Add league/container, event-manager to composer and mozart (#782)

classes/Dependencies/League/Container/Argument/ArgumentResolverInterface.php

@@ -0,0 +1,28 @@
+<?php declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+use Imagify\Dependencies\League\Container\ContainerAwareInterface;
+use ReflectionFunctionAbstract;
+
+interface ArgumentResolverInterface extends ContainerAwareInterface
+{
+    /**
+     * Resolve an array of arguments to their concrete implementations.
+     *
+     * @param array $arguments
+     *
+     * @return array
+     */
+    public function resolveArguments(array $arguments) : array;
+
+    /**
+     * Resolves the correct arguments to be passed to a method.
+     *
+     * @param ReflectionFunctionAbstract $method
+     * @param array                      $args
+     *
+     * @return array
+     */
+    public function reflectArguments(ReflectionFunctionAbstract $method, array $args = []) : array;
+}

classes/Dependencies/League/Container/Argument/ArgumentResolverTrait.php

@@ -0,0 +1,120 @@
+<?php declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+use Imagify\Dependencies\League\Container\Container;
+use Imagify\Dependencies\League\Container\Exception\{ContainerException, NotFoundException};
+use Imagify\Dependencies\League\Container\ReflectionContainer;
+use Imagify\Dependencies\Psr\Container\ContainerInterface;
+use ReflectionFunctionAbstract;
+use ReflectionParameter;
+
+trait ArgumentResolverTrait
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function resolveArguments(array $arguments) : array
+    {
+        return array_map(function ($argument) {
+            $justStringValue = false;
+
+            if ($argument instanceof RawArgumentInterface) {
+                return $argument->getValue();
+            } elseif ($argument instanceof ClassNameInterface) {
+                $id = $argument->getClassName();
+            } elseif (!is_string($argument)) {
+                return $argument;
+            } else {
+                $justStringValue = true;
+                $id = $argument;
+            }
+
+            $container = null;
+
+            try {
+                $container = $this->getLeagueContainer();
+            } catch (ContainerException $e) {
+                if ($this instanceof ReflectionContainer) {
+                    $container = $this;
+                }
+            }
+
+            if ($container !== null) {
+                try {
+                    return $container->get($id);
+                } catch (NotFoundException $exception) {
+                    if ($argument instanceof ClassNameWithOptionalValue) {
+                        return $argument->getOptionalValue();
+                    }
+
+                    if ($justStringValue) {
+                        return $id;
+                    }
+
+                    throw $exception;
+                }
+            }
+
+            if ($argument instanceof ClassNameWithOptionalValue) {
+                return $argument->getOptionalValue();
+            }
+
+            // Just a string value.
+            return $id;
+        }, $arguments);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function reflectArguments(ReflectionFunctionAbstract $method, array $args = []) : array
+    {
+        $arguments = array_map(function (ReflectionParameter $param) use ($method, $args) {
+            $name = $param->getName();
+            $type = $param->getType();
+
+            if (array_key_exists($name, $args)) {
+                return new RawArgument($args[$name]);
+            }
+
+            if ($type) {
+                if (PHP_VERSION_ID >= 70100) {
+                    $typeName = $type->getName();
+                } else {
+                    $typeName = (string) $type;
+                }
+
+                $typeName = ltrim($typeName, '?');
+
+                if ($param->isDefaultValueAvailable()) {
+                    return new ClassNameWithOptionalValue($typeName, $param->getDefaultValue());
+                }
+
+                return new ClassName($typeName);
+            }
+
+            if ($param->isDefaultValueAvailable()) {
+                return new RawArgument($param->getDefaultValue());
+            }
+
+            throw new NotFoundException(sprintf(
+                'Unable to resolve a value for parameter (%s) in the function/method (%s)',
+                $name,
+                $method->getName()
+            ));
+        }, $method->getParameters());
+
+        return $this->resolveArguments($arguments);
+    }
+
+    /**
+     * @return ContainerInterface
+     */
+    abstract public function getContainer() : ContainerInterface;
+
+    /**
+     * @return Container
+     */
+    abstract public function getLeagueContainer() : Container;
+}

classes/Dependencies/League/Container/Argument/ClassName.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+class ClassName implements ClassNameInterface
+{
+    /**
+     * @var string
+     */
+    protected $value;
+
+    /**
+     * Construct.
+     *
+     * @param string $value
+     */
+    public function __construct(string $value)
+    {
+        $this->value = $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getClassName() : string
+    {
+        return $this->value;
+    }
+}

classes/Dependencies/League/Container/Argument/ClassNameInterface.php

@@ -0,0 +1,13 @@
+<?php declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+interface ClassNameInterface
+{
+    /**
+     * Return the class name.
+     *
+     * @return string
+     */
+    public function getClassName() : string;
+}

classes/Dependencies/League/Container/Argument/ClassNameWithOptionalValue.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+class ClassNameWithOptionalValue implements ClassNameInterface
+{
+    /**
+     * @var string
+     */
+    private $className;
+
+    /**
+     * @var mixed
+     */
+    private $optionalValue;
+
+    /**
+     * @param string $className
+     * @param mixed $optionalValue
+     */
+    public function __construct(string $className, $optionalValue)
+    {
+        $this->className = $className;
+        $this->optionalValue = $optionalValue;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getClassName(): string
+    {
+        return $this->className;
+    }
+
+    public function getOptionalValue()
+    {
+        return $this->optionalValue;
+    }
+}

classes/Dependencies/League/Container/Argument/RawArgument.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+class RawArgument implements RawArgumentInterface
+{
+    /**
+     * @var mixed
+     */
+    protected $value;
+
+    /**
+     * Construct.
+     *
+     * @param mixed $value
+     */
+    public function __construct($value)
+    {
+        $this->value = $value;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+}

classes/Dependencies/League/Container/Argument/RawArgumentInterface.php

@@ -0,0 +1,13 @@
+<?php declare(strict_types=1);
+
+namespace Imagify\Dependencies\League\Container\Argument;
+
+interface RawArgumentInterface
+{
+    /**
+     * Return the value of the raw argument.
+     *
+     * @return mixed
+     */
+    public function getValue();
+}