binder.php

См. документацию.

<?php
 
namespace Bitrix\Main\Engine\AutoWire;
 
use Bitrix\Main\DI\ServiceLocator;
use Bitrix\Main\ObjectNotFoundException;
use Bitrix\Main\Result;
use Bitrix\Main\Validation\Engine\AutoWire\ValidationChecker;
use Psr\Container\NotFoundExceptionInterface;
 
class Binder
{
    const STATUS_FOUND     = true;
    const STATUS_NOT_FOUND = false;
 
    private $instance;
    private $method;
    private $configuration = [];
    private static $globalAutoWiredParameters;
    private $autoWiredParameters = [];
    private $reflectionFunctionAbstract;
    private $methodParams = null;
    private $args = null;
 
    public function __construct($instance, $method, $configuration = [])
    {
        $this->instance = $instance;
        $this->method = $method;
        $this->configuration = $configuration;
 
        if ($this->instance === null)
        {
            $this->buildReflectionFunction();
        }
        else
        {
            $this->buildReflectionMethod();
        }
 
    }
 
    final public static function buildForFunction($callable, $configuration = [])
    {
        return new static(null, $callable, $configuration);
    }
 
    final public static function buildForMethod($instance, $method, $configuration = [])
    {
        return new static($instance, $method, $configuration);
    }
 
    private function buildReflectionMethod()
    {
        $this->reflectionFunctionAbstract = new \ReflectionMethod($this->instance, $this->method);
        $this->reflectionFunctionAbstract->setAccessible(true);
    }
 
    private function buildReflectionFunction()
    {
        $this->reflectionFunctionAbstract = new \ReflectionFunction($this->method);
    }

    public function getInstance()
    {
        return $this->instance;
    }

    public function getMethod()
    {
        return $this->method;
    }

    public function getConfiguration()
    {
        return $this->configuration;
    }

    public function setConfiguration($configuration)
    {
        $this->configuration = $configuration;
 
        return $this;
    }

    public function setAutoWiredParameters(array $parameters)
    {
        $this->autoWiredParameters = [];
        
        foreach ($parameters as $parameter)
        {
            $this->appendAutoWiredParameter($parameter);
        }
        
        return $this;
    }
 
    public function appendAutoWiredParameter(Parameter $parameter)
    {
        $this->autoWiredParameters[] = $parameter;
 
        return $this;
    }

    public static function registerGlobalAutoWiredParameter(Parameter $parameter)
    {
        if (self::$globalAutoWiredParameters === null)
        {
            self::$globalAutoWiredParameters = new \SplObjectStorage();
        }
 
        if (!self::$globalAutoWiredParameters->contains($parameter))
        {
            self::$globalAutoWiredParameters[$parameter] = $parameter;
        }
    }

    public static function unRegisterGlobalAutoWiredParameter(Parameter $parameter): void
    {
        if (self::$globalAutoWiredParameters === null)
        {
            return;
        }
 
        if (self::$globalAutoWiredParameters->contains($parameter))
        {
            self::$globalAutoWiredParameters->detach($parameter);
        }
    }
 
    private function getPriorityByParameter(Parameter $parameter)
    {
        return $parameter->getPriority();
    }

    public function getAutoWiredParameters()
    {
        return $this->autoWiredParameters;
    }
 
    public function setSourcesParametersToMap(array $parameters)
    {
        $this->configuration['sourceParameters'] = $parameters;
 
        return $this;
    }
 
    public function getSourcesParametersToMap()
    {
        return $this->configuration['sourceParameters']?: [];
    }
 
    public function appendSourcesParametersToMap(array $parameter)
    {
        if (!isset($this->configuration['sourceParameters']))
        {
            $this->configuration['sourceParameters'] = [];
        }
 
        $this->configuration['sourceParameters'][] = $parameter;
 
        return $this;
    }

    final public function invoke()
    {
        try
        {
            if ($this->reflectionFunctionAbstract instanceof \ReflectionMethod)
            {
                return $this->reflectionFunctionAbstract->invokeArgs($this->instance, $this->getArgs());
            }
 
            if ($this->reflectionFunctionAbstract instanceof \ReflectionFunction)
            {
                return $this->reflectionFunctionAbstract->invokeArgs($this->getArgs());
            }
        }
        catch (\TypeError $exception)
        {
            throw $exception;
        }
        catch (\ErrorException $exception)
        {
            throw $exception;
        }
 
        return null;
    }

    final public function getMethodParams()
    {
        if ($this->methodParams === null)
        {
            $this->bindParams();
        }
 
        return $this->methodParams;
    }

    final public function setMethodParams(array $params)
    {
        $this->methodParams = $params;
        $this->args = array_values($params);
 
        return $this;
    }

    final public function getArgs()
    {
        if ($this->args === null)
        {
            $this->bindParams();
        }
 
        return $this->args;
    }
 
    private function bindParams()
    {
        $this->args = $this->methodParams = [];
 
        foreach ($this->reflectionFunctionAbstract->getParameters() as $param)
        {
            $value = $this->getParameterValue($param);
            $this->args[] = $this->methodParams[$param->getName()] = $value;
        }
 
        return $this->args;
    }

    private function getAutoWiredByClass(\ReflectionParameter $reflectionParameter)
    {
        $result = new \SplPriorityQueue();
        foreach ($this->getAllAutoWiredParameters() as $parameter)
        {
            if ($parameter->match($reflectionParameter))
            {
                $result->insert($parameter, $this->getPriorityByParameter($parameter));
            }
        }
 
        return $result;
    }

    private function getAllAutoWiredParameters()
    {
        $list = $this->getAutoWiredParameters();
        if (self::$globalAutoWiredParameters)
        {
            foreach (self::$globalAutoWiredParameters as $globalAutoWiredParameter)
            {
                $list[] = $globalAutoWiredParameter;
            }
        }
 
        return $list;
    }
 
    protected function constructValue(\ReflectionParameter $parameter, Parameter $autoWireParameter, Result $captureResult): Result
    {
        $result = new Result();
 
        $constructedValue = $autoWireParameter->constructValue($parameter, $captureResult);
 
        $result->setData([
            'value' => $constructedValue,
        ]);
 
        return $result;
    }

    private function getParameterValue(\ReflectionParameter $parameter)
    {
        $sourceParameters = $this->getSourcesParametersToMap();
 
        $reflectionType = $parameter->getType();
        if (
            ($reflectionType instanceof \ReflectionUnionType)
            || ($reflectionType instanceof \ReflectionIntersectionType)
        )
        {
            throw new BinderArgumentException(
                "Currently there is no support for union or intersection types {{$parameter->getName()}}",
                $parameter
            );
        }
 
        if (($reflectionType instanceof \ReflectionNamedType) && !$reflectionType->isBuiltin())
        {
            foreach ($this->getAutoWiredByClass($parameter) as $autoWireParameter)
            {
                $result = $autoWireParameter->captureData($parameter, $sourceParameters, $this->getAllAutoWiredParameters());
                if (!$result->isSuccess())
                {
                    continue;
                }
 
                $constructedValue = null;
                $constructResult = $this->constructValue($parameter, $autoWireParameter, $result);
                if ($constructResult->isSuccess())
                {
                    ['value' => $constructedValue] = $constructResult->getData();
                }
 
                if ($constructedValue === null)
                {
                    if ($parameter->allowsNull())
                    {
                        return null;
                    }
 
                    if ($parameter->isDefaultValueAvailable())
                    {
                        return $parameter->getDefaultValue();
                    }
 
                    throw new BinderArgumentException(
                        "Could not construct parameter {{$parameter->getName()}}",
                        $parameter,
                        $constructResult->getErrors(),
                    );
                }
 
                (new ValidationChecker($parameter, $constructedValue))->check();
 
                return $constructedValue;
            }
 
            $reflectionClass = new \ReflectionClass($reflectionType->getName());
            if ($reflectionClass->isEnum())
            {
                $enum = new \ReflectionEnum($reflectionType->getName());
                $backedType = $enum->getBackingType();
                if ($backedType && $enum->isBacked())
                {
                    $backedValue = $this->findParameterInSourceList($parameter->getName(), $status);
                    if ($status === self::STATUS_NOT_FOUND)
                    {
                        if ($parameter->isDefaultValueAvailable())
                        {
                            return $parameter->getDefaultValue();
                        }
 
                        throw new BinderArgumentException(
                            "Could not find value for parameter {{$parameter->getName()}}",
                            $parameter
                        );
                    }
                    $declarationChecker = new TypeDeclarationChecker($backedType, $backedValue);
                    if (!$declarationChecker->isSatisfied())
                    {
                        throw new BinderArgumentException(
                            "Invalid value {{$backedValue}} to match with parameter {{$parameter->getName()}}. Should be value of type {$backedType->getName()}.",
                            $parameter
                        );
                    }
 
                    $enumValue = $reflectionType->getName()::tryFrom($backedValue);
                    if ($enumValue)
                    {
                        return $enumValue;
                    }
                }
            }
 
            if ($parameter->isDefaultValueAvailable())
            {
                return $parameter->getDefaultValue();
            }
 
            try
            {
                if (class_exists($reflectionType->getName()))
                {
                    if ($object = ServiceLocator::getInstance()->get($reflectionType->getName()))
                    {
                        return $object;
                    }
                }
            }
            catch (ObjectNotFoundException $exception)
            {
                throw new BinderArgumentException(
                    $exception->getMessage(),
                    $parameter
                );
            }
 
            $exceptionMessage = "Could not find value for parameter to build auto wired argument {{$reflectionType->getName()} \${$parameter->getName()}}";
            if (isset($result) && ($result instanceof Result) && $result->getErrorMessages())
            {
                $exceptionMessage = $result->getErrorMessages()[0];
            }
 
            throw new BinderArgumentException(
                $exceptionMessage,
                $parameter
            );
        }
 
        $value = $this->findParameterInSourceList($parameter->getName(), $status);
        if ($status === self::STATUS_NOT_FOUND)
        {
            if ($parameter->isDefaultValueAvailable())
            {
                return $parameter->getDefaultValue();
            }
 
            throw new BinderArgumentException(
                "Could not find value for parameter {{$parameter->getName()}}",
                $parameter
            );
        }
        if ($reflectionType instanceof \ReflectionNamedType)
        {
            $declarationChecker = new TypeDeclarationChecker($reflectionType, $value);
            if (!$declarationChecker->isSatisfied())
            {
                throw new BinderArgumentException(
                    "Invalid value {{$value}} to match with parameter {{$parameter->getName()}}. Should be value of type {$reflectionType->getName()}.",
                    $parameter
                );
            }
            if ($declarationChecker->isArray())
            {
                $value = (array)$value;
            }
 
            (new ValidationChecker($parameter, $value))->check();
        }
 
        return $value;
    }
 
    private function findParameterInSourceList($name, &$status)
    {
        $status = self::STATUS_FOUND;
        foreach ($this->getSourcesParametersToMap() as $source)
        {
            if (isset($source[$name]))
            {
                return $source[$name];
            }
 
            if ($source instanceof \ArrayAccess && $source->offsetExists($name))
            {
                return $source[$name];
            }
 
            if (is_array($source) && array_key_exists($name, $source))
            {
                return $source[$name];
            }
        }
 
        $status = self::STATUS_NOT_FOUND;
 
        return null;
    }
}