samsonframework\container\annotation\Inject

Complexity

Total Complexity

17

Size/Duplication

Total Lines	121
Duplicated Lines	7.44 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes	6
Bugs	0	Features	3

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	toPropertyMetadata()	0	11	1
B	validate()	0	23	5
A	buildFullClassName()	9	9	3
A	checkInheritanceViolation()	0	14	3
A	checkInterfaceWithoutClassName()	0	6	3

<?php
declare(strict_types = 1);

/**
 * Created by PhpStorm.
 * User: root
 * Date: 27.07.2016
 * Time: 1:55.
 */
namespace samsonframework\container\annotation;

use samsonframework\container\metadata\PropertyMetadata;

/**
 * Injection annotation class.
 *
 * @Annotation
 */
class Inject extends CollectionValue implements PropertyInterface
{
    /** @var string Injectable dependency */
    protected $dependency;

    /**
     * Inject constructor.
     *
     * @param array $valueOrValues
     */
    public function __construct(array $valueOrValues)
    {
        parent::__construct($valueOrValues);

        // Get first argument from annotation
        $this->dependency = $this->collection[0] ?? null;

        // Removed first namespace separator if present
        $this->dependency = is_string($this->dependency) ? ltrim($this->dependency, '\\') : $this->dependency;
    }

    /** {@inheritdoc} */
    public function toPropertyMetadata(PropertyMetadata $propertyMetadata)
    {
        // Get @Inject("value")
        $propertyMetadata->dependency = $this->dependency;

        $this->validate(
            $propertyMetadata->typeHint,
            $propertyMetadata->dependency,
            $propertyMetadata->classMetadata->nameSpace
        );
    }

    /**
     * Validate dependency.
     *
     * @param string $type
     * @param string $dependency
     * @param string $namespace
     */
    protected function validate(&$type, &$dependency, $namespace)
    {
        $dependency = $this->buildFullClassName($dependency, $namespace);
        $type = $this->buildFullClassName($type, $namespace);

        // Check for inheritance violation
        if ($this->checkInheritanceViolation($type, $dependency)) {
            throw new \InvalidArgumentException(
                '@Inject dependency violates ' . $type . ' inheritance with ' . $dependency
            );
        }

        if ($this->checkInterfaceWithoutClassName($type, $dependency)) {
            throw new \InvalidArgumentException(
                'Cannot @Inject interface, inherited class name should be specified
                ');
        }

        // Empty @Inject with type hint - use type hine as dependency
        if ($dependency === null && $type !== null) {
            $dependency = $type;
        }
    }

    /**
     * Build full class name.
     *
     * @param string $className Full or short class name
     * @param string $namespace Name space
     *
     * @return string Full class name
     */
    protected function buildFullClassName($className, $namespace)

This method seems to be duplicated in your project.

    {
        // Check if we need to append namespace to dependency
        if ($className !== null && strpos($className, '\\') === false) {
            return $namespace . '\\' . $className;
        }

        return $className;
    }

    /**
     * Check if @Inject violates inheritance.
     *
     * @param string $type       Property/Parameter type
     * @param string $dependency @Inject value
     *
     * @return bool True if @Inject violates inheritance
     */
    protected function checkInheritanceViolation($type, $dependency) : bool
    {
        // Check for inheritance violation
        if ($dependency !== null && $type !== null) {
            $inheritance = array_merge(
                [$dependency],
                class_parents($dependency),
                class_implements($dependency)
            );
            return !in_array($type, $inheritance, true);
        }

        return false;
    }

    /**
     * Check if @Inject has no class name and type hint is interface.
     *
     * @param string $type       Property/Parameter type
     * @param string $dependency @Inject value
     *
     * @return bool True if @Inject has no class name and type hint is interface.
     */
    protected function checkInterfaceWithoutClassName($type, $dependency) : bool
    {
        return $type !== null
        && $dependency === null
        && (new \ReflectionClass($type))->isInterface();
    }
}