PhpScanner.php

Go to the documentation of this file.

<?php
namespace Magento\Setup\Module\Di\Code\Scanner;

use Magento\Framework\Api\Code\Generator\ExtensionAttributesGenerator;
use Magento\Framework\Api\Code\Generator\ExtensionAttributesInterfaceGenerator;
use Magento\Framework\ObjectManager\Code\Generator\Factory as FactoryGenerator;
use Magento\Setup\Module\Di\Compiler\Log\Log;
use \Magento\Framework\Reflection\TypeProcessor;

class PhpScanner implements ScannerInterface
{
    protected $_log;

    private $typeProcessor;

    public function __construct(Log $log, TypeProcessor $typeProcessor = null)
    {
        $this->_log = $log;
        $this->typeProcessor = $typeProcessor
            ?: \Magento\Framework\App\ObjectManager::getInstance()->get(TypeProcessor::class);
    }

    protected function _findMissingClasses($file, $classReflection, $methodName, $entityType)
    {
        $missingClasses = [];
        if ($classReflection->hasMethod($methodName)) {
            $constructor = $classReflection->getMethod($methodName);
            $parameters = $constructor->getParameters();
            foreach ($parameters as $parameter) {
                preg_match('/\[\s<\w+?>\s([\w\\\\]+)/s', $parameter->__toString(), $matches);
                if (isset($matches[1]) && substr($matches[1], -strlen($entityType)) == $entityType) {
                    $missingClassName = $matches[1];
                    if ($this->shouldGenerateClass($missingClassName, $entityType, $file)) {
                        $missingClasses[] = $missingClassName;
                    }
                }
            }
        }
        return $missingClasses;
    }

    protected function getSourceClassName($missingClassName, $entityType)
    {
        $sourceClassName = rtrim(substr($missingClassName, 0, -strlen($entityType)), '\\');
        $entityType = lcfirst($entityType);
        if ($entityType == ExtensionAttributesInterfaceGenerator::ENTITY_TYPE
            || $entityType == ExtensionAttributesGenerator::ENTITY_TYPE
        ) {
            return $sourceClassName . 'Interface';
        } elseif ($entityType == FactoryGenerator::ENTITY_TYPE) {
            $extensionAttributesSuffix = ucfirst(ExtensionAttributesGenerator::ENTITY_TYPE);
            if (substr($sourceClassName, -strlen($extensionAttributesSuffix)) == $extensionAttributesSuffix) {
                $extensionAttributesClass = substr(
                    $sourceClassName,
                    0,
                    -strlen(ExtensionAttributesGenerator::ENTITY_TYPE)
                );
                $sourceClassName = $extensionAttributesClass . 'Interface';
            }
        }
        return $sourceClassName;
    }

    protected function _fetchFactories($reflectionClass, $file)
    {
        $factorySuffix = '\\' . ucfirst(FactoryGenerator::ENTITY_TYPE);
        $absentFactories = $this->_findMissingClasses(
            $file,
            $reflectionClass,
            '__construct',
            ucfirst(FactoryGenerator::ENTITY_TYPE)
        );
        foreach ($absentFactories as $key => $absentFactory) {
            if (substr($absentFactory, -strlen($factorySuffix)) == $factorySuffix) {
                $entityName = rtrim(substr($absentFactory, 0, -strlen($factorySuffix)), '\\');
                $this->_log->add(
                    Log::CONFIGURATION_ERROR,
                    $absentFactory,
                    'Invalid Factory declaration for class ' . $entityName . ' in file ' . $file
                );
                unset($absentFactories[$key]);
            }
        }
        return $absentFactories;
    }

    protected function _fetchMissingExtensionAttributesClasses($reflectionClass, $file)
    {
        $missingExtensionInterfaces = [];
        $methodName = 'getExtensionAttributes';
        $entityType = ucfirst(\Magento\Framework\Api\Code\Generator\ExtensionAttributesInterfaceGenerator::ENTITY_TYPE);
        if ($reflectionClass->hasMethod($methodName) && $reflectionClass->isInterface()) {
            $returnType = $this->typeProcessor->getGetterReturnType(
                (new \Zend\Code\Reflection\ClassReflection($reflectionClass->getName()))->getMethod($methodName)
            );
            $missingClassName = $returnType['type'];
            if ($this->shouldGenerateClass($missingClassName, $entityType, $file)) {
                $missingExtensionInterfaces[] = $missingClassName;
            }
        }
        $missingExtensionClasses = [];
        $missingExtensionFactories = [];
        foreach ($missingExtensionInterfaces as $missingExtensionInterface) {
            $extension = rtrim(substr($missingExtensionInterface, 0, -strlen('Interface')), '\\');
            if (!class_exists($extension)) {
                $missingExtensionClasses[] = $extension;
            }
            $extensionFactory = $extension . 'Factory';
            if (!class_exists($extensionFactory)) {
                $missingExtensionFactories[] = $extensionFactory;
            }
        }
        return array_merge($missingExtensionInterfaces, $missingExtensionClasses, $missingExtensionFactories);
    }

    public function collectEntities(array $files)
    {
        $output = [];
        foreach ($files as $file) {
            $classes = $this->_getDeclaredClasses($file);
            foreach ($classes as $className) {
                $reflectionClass = new \ReflectionClass($className);
                $output = array_merge(
                    $output,
                    $this->_fetchFactories($reflectionClass, $file),
                    $this->_fetchMissingExtensionAttributesClasses($reflectionClass, $file)
                );
            }
        }
        return array_unique($output);
    }

    protected function _fetchNamespace($tokenIterator, $count, $tokens)
    {
        $namespace = '';
        for ($tokenOffset = $tokenIterator + 1; $tokenOffset < $count; ++$tokenOffset) {
            if ($tokens[$tokenOffset][0] === T_STRING) {
                $namespace .= "\\" . $tokens[$tokenOffset][1];
            } elseif ($tokens[$tokenOffset] === '{' || $tokens[$tokenOffset] === ';') {
                break;
            }
        }
        return $namespace;
    }

    protected function _fetchClasses($namespace, $tokenIterator, $count, $tokens)
    {
        $classes = [];
        for ($tokenOffset = $tokenIterator + 1; $tokenOffset < $count; ++$tokenOffset) {
            if ($tokens[$tokenOffset] === '{') {
                $classes[] = $namespace . "\\" . $tokens[$tokenIterator + 2][1];
            }
        }
        return $classes;
    }

    protected function _getDeclaredClasses($file)
    {
        $classes = [];
        $namespace = '';
        $tokens = token_get_all(file_get_contents($file));
        $count = count($tokens);

        for ($tokenIterator = 0; $tokenIterator < $count; $tokenIterator++) {
            if ($tokens[$tokenIterator][0] == T_NAMESPACE) {
                $namespace .= $this->_fetchNamespace($tokenIterator, $count, $tokens);
            }

            if (($tokens[$tokenIterator][0] == T_CLASS || $tokens[$tokenIterator][0] == T_INTERFACE)
                && $tokens[$tokenIterator - 1][0] != T_DOUBLE_COLON
            ) {
                $classes = array_merge($classes, $this->_fetchClasses($namespace, $tokenIterator, $count, $tokens));
            }
        }
        return array_unique($classes);
    }

    private function shouldGenerateClass($missingClassName, $entityType, $file)
    {
        try {
            if (class_exists($missingClassName)) {
                return false;
            }
        } catch (\RuntimeException $e) {
        }
        $sourceClassName = $this->getSourceClassName($missingClassName, $entityType);
        if (!class_exists($sourceClassName) && !interface_exists($sourceClassName)) {
            $this->_log->add(
                Log::CONFIGURATION_ERROR,
                $missingClassName,
                "Invalid {$entityType} for nonexistent class {$sourceClassName} in file {$file}"
            );
            return false;
        }
        return true;
    }
}