EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\ReflectionHelper

Complexity

Total Complexity

17

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Test Coverage

Coverage

24.47%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getTraitImplementingMethod()	0	24	5
A	getFakerProviderFqnFromFieldTraitReflection()	0	13	1
A	getEntityNamespaceRootFromEntityReflection()	0	7	1
A	getUseStatements()	0	6	1
B	getTraitProvidingProperty()	0	27	7
A	getMethodBody()	0	9	1
A	__construct()	0	3	1

<?php declare(strict_types=1);

namespace EdmondsCommerce\DoctrineStaticMeta\CodeGeneration;

use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\AbstractGenerator;
use ts\Reflection\ReflectionClass;

class ReflectionHelper
{

    /**
     * @var NamespaceHelper
     */
    protected $namespaceHelper;

    public function __construct(NamespaceHelper $namespaceHelper)
    {
        $this->namespaceHelper = $namespaceHelper;
    }

    /**
     * @param ReflectionClass $fieldTraitReflection
     *
     * @return string
     */
    public function getFakerProviderFqnFromFieldTraitReflection(ReflectionClass $fieldTraitReflection
    ): string
    {
        return \str_replace(
            [
                '\\Traits\\',
                'FieldTrait',
            ],
            [
                '\\FakerData\\',
                'FakerData',
            ],
            $fieldTraitReflection->getName()
        );
    }

    /**
     * Work out the entity namespace root from a single entity reflection object.
     *
     * @param ReflectionClass $entityReflection
     *
     * @return string
     */
    public function getEntityNamespaceRootFromEntityReflection(
        ReflectionClass $entityReflection
    ): string {
        return $this->namespaceHelper->tidy(
            $this->namespaceHelper->getNamespaceRootToDirectoryFromFqn(

It seems like $this->namespaceHelper->getNamespaceRootToDirectoryFromFqn($entityReflection->getName(), EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\AbstractGenerator::ENTITIES_FOLDER_NAME) can also be of type null; however, parameter $namespace of EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper::tidy() does only seem to accept string, maybe add an additional type check?

                $entityReflection->getName(),
                AbstractGenerator::ENTITIES_FOLDER_NAME
            )
        );
    }

    /**
     * Find which trait is implementing a method in a class
     *
     * @param ReflectionClass $class
     * @param string          $methodName
     *
     * @return ReflectionClass
     * @throws \ReflectionException
     */
    public function getTraitImplementingMethod(ReflectionClass $class, string $methodName): ReflectionClass
    {
        $traitsWithMethod = [];
        foreach ($class->getTraits() as $trait) {
            try {
                $trait->getMethod($methodName);
                $traitsWithMethod[] = $trait;
            } catch (\ReflectionException $e) {

Consider adding a comment why this CATCH block is empty.

            }
        }
        if (count($traitsWithMethod) > 1) {
            throw new \RuntimeException(
                'Found more than one trait implementing the method ' . $methodName . ' in ' .
                $class->getShortName()
            );
        }
        if ([] === $traitsWithMethod) {
            throw new \RuntimeException(
                'Failed finding trait implementing the method ' . $methodName . ' in ' .
                $class->getShortName()
            );
        }

        return current($traitsWithMethod);
    }

    /**
     * Find which trait is implementing a method in a class
     *
     * @param ReflectionClass $class
     * @param string          $propertyName
     *
     * @return ReflectionClass
     * @throws \ReflectionException
     */
    public function getTraitProvidingProperty(ReflectionClass $class, string $propertyName): ReflectionClass
    {
        $traitsWithProperty = [];
        foreach ($class->getTraits() as $trait) {
            try {
                $trait->getProperty($propertyName);
                $traitsWithProperty[] = $trait;
            } catch (\ReflectionException $e) {

Consider adding a comment why this CATCH block is empty.

            }
        }
        if ([] === $traitsWithProperty) {
            if ($class->isTrait() && $class->hasProperty($propertyName)) {
                return $class;
            }
            throw new \RuntimeException(
                'Failed finding trait providing the property ' . $propertyName . ' in ' .
                $class->getShortName()
            );
        }
        if (count($traitsWithProperty) > 1) {
            throw new \RuntimeException(
                'Found more than one trait providing the property ' . $propertyName . ' in ' .
                $class->getShortName()
            );
        }

        return current($traitsWithProperty);
    }

    /**
     * Get the full method body using reflection
     *
     * @param string          $methodName
     * @param ReflectionClass $reflectionClass
     *
     * @return string
     */
    public function getMethodBody(string $methodName, ReflectionClass $reflectionClass): string
    {
        $method      = $reflectionClass->getMethod($methodName);
        $startLine   = $method->getStartLine() - 1;
        $length      = $method->getEndLine() - $startLine;
        $lines       = file($reflectionClass->getFileName());
        $methodLines = \array_slice($lines, $startLine, $length);

It seems like $lines can also be of type false; however, parameter $array of array_slice() does only seem to accept array, maybe add an additional type check?

        return implode('', $methodLines);
    }

    /**
     * @param ReflectionClass $reflectionClass
     *
     * @return array|string[]
     */
    public function getUseStatements(ReflectionClass $reflectionClass): array
    {
        $content = \ts\file_get_contents($reflectionClass->getFileName());
        preg_match_all('%^use.+?;%m', $content, $matches);

        return $matches[0];
    }
}