Gica\CodeAnalysis\Shared\ClassSorter\ByConstructorDependencySorter

Complexity

Total Complexity

11

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__invoke()	0	12	3
A	doesClassDependsOnClass()	0	12	2
A	getClassDependencies()	0	9	2
A	isParentClassOfAny()	0	11	2
A	classNameFromParameter()	0	4	1
A	classNameFromParameters()	0	10	1

<?php
/******************************************************************************
 * Copyright (c) 2016 Constantin Galbenu <gica.galbenu@gmail.com>             *
 ******************************************************************************/

namespace Gica\CodeAnalysis\Shared\ClassSorter;


use Gica\CodeAnalysis\Shared\ClassSorter;

class ByConstructorDependencySorter implements ClassSorter
{

    public function __invoke(\ReflectionClass $a, \ReflectionClass $b)
    {
        if ($this->doesClassDependsOnClass($a, $b)) {
            return 1;
        }

        if ($this->doesClassDependsOnClass($b, $a)) {
            return -1;
        }

        return strcmp($a->name, $b->name);
    }

    private function doesClassDependsOnClass(\ReflectionClass $consumerClass, \ReflectionClass $consumedClass)
    {
        $dependencies = $this->getClassDependencies($consumerClass);

        if ($this->isParentClassOfAny($consumedClass, $dependencies)) {
            //echo "{$consumerClass->name} depends on {$consumedClass->name}\n";
            return true;
        } else {
            //echo "{$a->name} does not depend on {$b->name}\n";
            return false;
        }
    }

    /**
     * @param \ReflectionClass $reflectionClass
     * @return string[]
     */
    private function getClassDependencies(\ReflectionClass $reflectionClass)
    {
        $constructor = $reflectionClass->getConstructor();
        if (!$constructor) {
            return [];
        }

        return $this->classNameFromParameters($constructor->getParameters());
    }


    private function isParentClassOfAny(\ReflectionClass $parentClass, $classes)
    {
        $isSubClassOf = function ($class) use ($parentClass) {
            return $parentClass->name === $class || is_subclass_of($class, $parentClass->name, true);

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if $parentClass->name can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

        };

        $filtered = array_filter($classes, $isSubClassOf);

        return count($filtered) > 0;

    }

    private function classNameFromParameter(\ReflectionParameter $parameter)
    {
        return $parameter->getClass()->name;
    }

    /**
     * @param \ReflectionParameter[] $parameters
     * @return string[]
     */
    private function classNameFromParameters(array $parameters)
    {
        $strings = array_map(function (\ReflectionParameter $parameter) {
            return $this->classNameFromParameter($parameter);
        }, $parameters);

        return array_filter($strings, function ($s) {
            return !!$s;
        });
    }
}