Rade\DI\Definitions\ValueDefinition

Complexity

Total Complexity

17

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	replace()	0	11	4
B	build()	0	36	11
A	getEntity()	0	3	1

<?php

declare(strict_types=1);

/*
 * This file is part of DivineNii opensource projects.
 *
 * PHP version 7.4 and above required
 *
 * @author    Divine Niiquaye Ibok <divineibok@gmail.com>
 * @copyright 2021 DivineNii (https://divinenii.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Rade\DI\Definitions;

use PhpParser\Node\Expr;
use PhpParser\Node\Stmt\Return_;
use Rade\DI\Exceptions\ServiceCreationException;
use Rade\DI\Resolver;

/**
 * Represents a definition service that shouldn't be resolved.
 *
 * @author Divine Niiquaye Ibok <divineibok@gmail.com>
 */
class ValueDefinition implements DefinitionInterface, ShareableDefinitionInterface, DepreciableDefinitionInterface
{
    use Traits\DeprecationTrait;
    use Traits\VisibilityTrait;

    /** @var mixed */
    private $value;

    /**
     * Definition constructor.
     *
     * @param mixed $value
     */
    public function __construct($value, bool $shared = true)
    {
        $this->replace($value);
        $this->shared = $shared;
    }

    /**
     * Replace the existing value.
     *
     * @param mixed $value
     *
     * @return $this
     */
    public function replace($value)
    {
        if ($value instanceof DefinitionInterface) {
            throw new ServiceCreationException(\sprintf('A definition entity must not be an instance of "%s".', DefinitionInterface::class));
        } elseif ($value instanceof \PhpParser\Node && !$value instanceof Expr) {
            throw new ServiceCreationException(\sprintf('A definition entity must be an instance of "%s".', Expr::class));
        }

        $this->value = $value;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getEntity()
    {
        return $this->value;
    }

    /**
     * {@inheritdoc}
     */
    public function build(string $id, Resolver $resolver)
    {
        if (null === $builder = $resolver->getBuilder()) {
            if ($this->isDeprecated()) {
                $this->triggerDeprecation($id);
            }

            return \is_array($value = $this->value) ? $resolver->resolveArguments($value) : $value;
        }

        $defNode = $builder->method($resolver->createMethod($id))->makeProtected();

        if ($this->value instanceof \PhpParser\Node) {
            if ($this->value instanceof Expr\Array_) {
                $defNode->setReturnType('array');
            } elseif ($this->value instanceof Expr\New_) {
                $defNode->setReturnType($this->value->class->toString());

The method toString() does not exist on PhpParser\Node\Expr.

The method toString() does not exist on PhpParser\Node\Stmt\Class_.

            }
        } else {
            $defNode->setReturnType(\get_debug_type($this->value));
        }

        if ($this->isDeprecated()) {
            $defNode->addStmt($this->triggerDeprecation($id, $builder));
        }

        if ($this->lazy) {
            $lazyMethod = \is_array($this->value) ? 'resolveArguments' : 'resolve';
            $createdValue = $builder->methodCall($builder->propertyFetch($builder->var('this'), 'resolver'), $lazyMethod, [$this->value]);
        }

        if ($this->shared) {
            $createdValue = $this->triggerSharedBuild($id, $createdValue ?? $builder->val($this->value), $builder);
        }

        return $defNode->addStmt(new Return_($createdValue ?? $builder->val($this->value)));
    }
}