Ray\Di\DependencyProvider

Complexity

Total Complexity

13

Size/Duplication

Total Lines	97
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	isSingleton()	0	3	1
A	__toString()	0	5	1
A	inject()	0	15	4
A	setScope()	0	7	2
A	__construct()	0	4	1
A	accept()	0	7	1
A	__sleep()	0	3	1
A	register()	0	3	1
A	setContext()	0	3	1

<?php

declare(strict_types=1);

namespace Ray\Di;

use Ray\Compiler\CompileVisitor;

The type Ray\Compiler\CompileVisitor was not found. Maybe you did not declare it correctly or list all dependencies?

use function assert;
use function sprintf;

final class DependencyProvider implements DependencyInterface
{
    /** @var string */
    public $context;

    /**
     * Provider dependency
     *
     * @var Dependency
     */
    private $dependency;

    /** @var bool */
    private $isSingleton = false;

    /** @var ?mixed */
    private $instance;

    public function __construct(Dependency $dependency, string $context)
    {
        $this->dependency = $dependency;
        $this->context = $context;
    }

    /**
     * @return list<string>

The type Ray\Di\list was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public function __sleep()
    {
        return ['context', 'dependency', 'isSingleton'];

The expression return array('context', 'dependency', 'isSingleton') returns the type array<integer,string> which is incompatible with the documented return type Ray\Di\list.

    }

    public function __toString(): string
    {
        return sprintf(
            '(provider) %s',
            (string) $this->dependency
        );
    }

    /**
     * {@inheritdoc}
     */
    public function register(array &$container, Bind $bind): void
    {
        $container[(string) $bind] = $bind->getBound();
    }

    /**
     * {@inheritdoc}
     */
    public function inject(Container $container)
    {
        if ($this->isSingleton && $this->instance) {
            return $this->instance;
        }

        $provider = $this->dependency->inject($container);
        assert($provider instanceof ProviderInterface);
        if ($provider instanceof SetContextInterface) {
            $this->setContext($provider);
        }

        $this->instance = $provider->get();

        return $this->instance;
    }

    /**
     * {@inheritdoc}
     */
    public function setScope($scope): void
    {
        if ($scope !== Scope::SINGLETON) {
            return;
        }

        $this->isSingleton = true;
    }

    public function setContext(SetContextInterface $provider): void
    {
        $provider->setContext($this->context);
    }

    public function isSingleton(): bool
    {
        return $this->isSingleton;
    }

    public function accept(VisitorInterface $visitor): string
    {
        assert($visitor instanceof CompileVisitor);

        return $visitor->visitProvider(

The method visitProvider() does not exist on Ray\Di\VisitorInterface.

            $this->dependency,
            $this->context,
        );
    }
}