ormannotatecommand.php

<?php
namespace Bitrix\Main\Cli;
 
use Bitrix\Main\Application;
use Bitrix\Main\Loader;
use Bitrix\Main\ORM\Annotations\AnnotationInterface;
use Bitrix\Main\ORM\Annotations\AnnotationTrait;
use Bitrix\Main\ORM\Fields\ArrayField;
use Bitrix\Main\ORM\Fields\BooleanField;
use Bitrix\Main\ORM\Data\DataManager;
use Bitrix\Main\ORM\Entity;
use Bitrix\Main\ORM\Fields\DateField;
use Bitrix\Main\ORM\Fields\DatetimeField;
use Bitrix\Main\ORM\Fields\FloatField;
use Bitrix\Main\ORM\Fields\IntegerField;
use Bitrix\Main\Type\Date;
use Bitrix\Main\Type\DateTime;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputDefinition;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
 
class OrmAnnotateCommand extends Command implements AnnotationInterface
{
    use AnnotationTrait;
 
    protected $debug = 0;
 
    protected $modulesScanned = [];
 
    protected $filesIncluded = 0;
 
    protected $entitiesFound = [];
 
    protected $excludedFiles = [
        'main/lib/text/string.php',
        'main/lib/composite/compatibility/aliases.php',
        'sale/lib/delivery/extra_services/string.php',
    ];
 
    protected function configure()
    {
        $inBitrixDir = realpath(Application::getDocumentRoot().Application::getPersonalRoot()) === realpath(getcwd());
 
        $this
            // the name of the command (the part after "bin/console")
            ->setName('orm:annotate')
 
            // the short description shown while running "php bin/console list"
            ->setDescription('Scans project for ORM Entities.')
 
            // the full command description shown when running the command with
            // the "--help" option
            ->setHelp('This system command optimizes Entity Relation Map building.')
 
            ->setDefinition(
                new InputDefinition(array(
                    new InputArgument(
                        'output', InputArgument::OPTIONAL, 'File for annotations to be saved to',
                        $inBitrixDir
                            ? 'modules/orm_annotations.php'
                            : Application::getDocumentRoot().Application::getPersonalRoot().'/modules/orm_annotations.php'
                    ),
                    new InputOption(
                        'modules', 'm', InputOption::VALUE_OPTIONAL,
                        'Modules to be scanned, separated by comma.', 'main'
                    ),
                    new InputOption(
                        'clean', 'c', InputOption::VALUE_NONE,
                        'Clean current entity map.'
                    ),
                ))
            )
        ;
 
        // disable Loader::requireModule exception
        Loader::setRequireThrowException(false);
    }
 
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $output->writeln([
            'Entity Scanner',
            '==============',
            '',
        ]);
 
        $time = microtime(true);
        $memoryBefore = memory_get_usage();
 
        $exceptions = [];
 
        // handle already known classes (but we don't know their modules)
        // as long as there are no any Table by default, we can ignore it
        //$this->handleClasses($this->getDeclaredClassesDiff(), $input, $output);
 
        // skip already defined classes
        $this->getDeclaredClassesDiff();
 
        // scan dirs
        $inputModules = [];
        $inputModulesRaw = $input->getOption('modules');
 
        if (!empty($inputModulesRaw) && $inputModulesRaw != 'all')
        {
            $inputModules = explode(',', $inputModulesRaw);
        }
 
        $dirs = $this->getDirsToScan($inputModules, $input, $output);
 
        foreach ($dirs as $dir)
        {
            $this->scanDir($dir, $input, $output);
        }
 
        // scan for bitrix entities
        $this->scanBitrixEntities($inputModules, $input, $output);
 
        // get classes from outside regular filesystem (e.g. iblock, hlblock)
        try
        {
            $this->handleVirtualClasses($inputModules, $input, $output);
        }
        catch (\Exception $e)
        {
            $exceptions[] = $e;
        }
 
        // output file path
        $filePath = $input->getArgument('output');
        $filePath = ($filePath[0] == '/')
            ? $filePath // absolute
            : getcwd().'/'.$filePath; // relative
 
        // handle entities
        $annotations = [];
 
        // get current annotations
        if (!$input->getOption('clean') && file_exists($filePath) && is_readable($filePath))
        {
            $rawAnnotations = explode('/* '.static::ANNOTATION_MARKER, file_get_contents($filePath));
 
            foreach ($rawAnnotations as $rawAnnotation)
            {
                if ($rawAnnotation[0] === ':')
                {
                    $endPos = mb_strpos($rawAnnotation, ' */');
                    $entityClass = mb_substr($rawAnnotation, 1, $endPos - 1);
                    //$annotation = substr($rawAnnotation, $endPos + 3 + strlen(PHP_EOL));
 
                    $annotations[$entityClass] = '/* '.static::ANNOTATION_MARKER.rtrim($rawAnnotation);
                }
            }
        }
 
        // add/rewrite new entities
        foreach ($this->entitiesFound as $entityMeta)
        {
            try
            {
                $entityClass = $entityMeta['class'];
                $annotateUfOnly = $entityMeta['ufOnly'];
 
                $entity = Entity::getInstance($entityClass);
                $entityAnnotation = static::annotateEntity($entity, $annotateUfOnly);
 
                if (!empty($entityAnnotation))
                {
                    $annotations[$entityClass] = "/* ".static::ANNOTATION_MARKER.":{$entityClass} */".PHP_EOL;
                    $annotations[$entityClass] .= $entityAnnotation;
                }
            }
            catch (\Exception $e)
            {
                $exceptions[] = $e;
            }
        }
 
        // write to file
        $fileContent = '<?php'.PHP_EOL.PHP_EOL.join(PHP_EOL, $annotations);
        file_put_contents($filePath, $fileContent);
 
        $output->writeln('Map has been saved to: '.$filePath);
 
        // summary stats
        $time = round(microtime(true) - $time, 2);
        $memoryAfter = memory_get_usage();
        $memoryDiff = $memoryAfter - $memoryBefore;
 
        $output->writeln('Scanned modules: '.join(', ', $this->modulesScanned));
        $output->writeln('Scanned files: '.$this->filesIncluded);
        $output->writeln('Found entities: '.count($this->entitiesFound));
        $output->writeln('Time: '.$time.' sec');
        $output->writeln('Memory usage: '.(round($memoryAfter/1024/1024, 1)).'M (+'.(round($memoryDiff/1024/1024, 1)).'M)');
        $output->writeln('Memory peak usage: '.(round(memory_get_peak_usage()/1024/1024, 1)).'M');
 
        if (!empty($exceptions))
        {
            $io = new SymfonyStyle($input, $output);
 
            foreach ($exceptions as $e)
            {
                $io->warning('Exception: '.$e->getMessage().PHP_EOL.$e->getTraceAsString());
            }
        }
 
        return 0;
    }
 
    protected function getDirsToScan($inputModules, InputInterface $input, OutputInterface $output)
    {
        $basePaths = [
            //Application::getDocumentRoot().Application::getPersonalRoot().'/modules/',
            Application::getDocumentRoot().'/local/modules/'
        ];
 
        $dirs = [];
 
        foreach ($basePaths as $basePath)
        {
            if (!file_exists($basePath))
            {
                continue;
            }
 
            $moduleList = [];
 
            foreach (new \DirectoryIterator($basePath) as $item)
            {
                if($item->isDir() && !$item->isDot())
                {
                    $moduleList[] = $item->getFilename();
                }
            }
 
            // filter for input modules
            if (!empty($inputModules))
            {
                $moduleList = array_intersect($moduleList, $inputModules);
            }
 
            foreach ($moduleList as $moduleName)
            {
                // filter for installed modules
                if (!Loader::includeModule($moduleName))
                {
                    continue;
                }
 
                $libDir = $basePath.$moduleName.'/lib';
                if (is_dir($libDir) && is_readable($libDir))
                {
                    $dirs[] = $libDir;
                }
 
                $libDir = $basePath.$moduleName.'/dev/lib';
                if (is_dir($libDir) && is_readable($libDir))
                {
                    $dirs[] = $libDir;
                }
 
                $this->modulesScanned[] = $moduleName;
            }
        }
 
        return $dirs;
    }
 
    protected function scanBitrixEntities($inputModules, InputInterface $input, OutputInterface $output)
    {
        $basePath = Application::getDocumentRoot().Application::getPersonalRoot().'/modules/';
 
        // get all available modules
        $moduleList = [];
 
        foreach (new \DirectoryIterator($basePath) as $item)
        {
            if($item->isDir() && !$item->isDot())
            {
                $moduleList[] = $item->getFilename();
            }
        }
 
        // filter for input modules
        if (!empty($inputModules))
        {
            $moduleList = array_intersect($moduleList, $inputModules);
        }
 
        // collect classes
        foreach ($moduleList as $moduleName)
        {
            $ufPath = $basePath.$moduleName.'/meta/'.static::ANNOTATION_UF_FILENAME;
 
            if (file_exists($ufPath))
            {
                $classes = include $ufPath;
 
                foreach ($classes as $class)
                {
                    if (class_exists($class))
                    {
                        $this->entitiesFound[] = [
                            'class' => $class,
                            'ufOnly' => true,
                        ];
                    }
                }
            }
        }
 
        // clear diff buffer
        $this->getDeclaredClassesDiff();
    }
 
    protected function registerFallbackAutoload()
    {
        spl_autoload_register(function($className) {
            list($vendor, $module) = explode('\\', $className);
 
            if (!empty($module))
            {
                Loader::includeModule($module);
            }
 
            return Loader::autoLoad($className);
        });
    }
 
    protected function scanDir($dir, InputInterface $input, OutputInterface $output)
    {
        $this->debug($output,'scan dir: '.$dir);
 
        $this->registerFallbackAutoload();
 
        foreach (
            $iterator = new \RecursiveIteratorIterator(
                new \RecursiveDirectoryIterator($dir, \RecursiveDirectoryIterator::SKIP_DOTS | \RecursiveDirectoryIterator::FOLLOW_SYMLINKS),
                \RecursiveIteratorIterator::SELF_FIRST) as $item
        )
        {
            // check for stop list
            foreach ($this->excludedFiles as $excludedFile)
            {
                $currentPath = str_replace('\\', '/', $item->getPathname());
                if (mb_substr($currentPath, -mb_strlen($excludedFile)) === $excludedFile)
                {
                    continue 2;
                }
            }
 
            if ($item->isFile() && $item->isReadable() && mb_substr($item->getFilename(), -4) == '.php')
            {
                $this->debug($output,'handle file: '.$item->getPathname());
 
                try
                {
                    // get classes from file
                    include_once $item->getPathname();
                    $this->filesIncluded++;
 
                    $classes = $this->getDeclaredClassesDiff();
 
                    // check classes
                    $this->handleClasses($classes, $input, $output);
                }
                catch (\Throwable $e) // php7
                {
                    $this->debug($output, $e->getMessage());
                }
                catch (\Exception $e) // php5
                {
                    $this->debug($output, $e->getMessage());
                }
            }
        }
    }
 
    protected function handleClasses($classes, InputInterface $input, OutputInterface $output)
    {
        foreach ($classes as $class)
        {
            $debugMsg = $class;
 
            if (is_subclass_of($class, DataManager::class) && mb_substr($class, -5) == 'Table')
            {
                if ((new \ReflectionClass($class))->isAbstract())
                {
                    continue;
                }
 
                $debugMsg .= ' found!';
                $this->entitiesFound[] = [
                    'class' => $class,
                    'ufOnly' => false,
                ];
            }
 
            $this->debug($output, $debugMsg);
        }
    }
 
    protected function getDeclaredClassesDiff()
    {
        static $lastDeclaredClasses = [];
 
        $currentDeclaredClasses = get_declared_classes();
        $diff = array_diff($currentDeclaredClasses, $lastDeclaredClasses);
        $lastDeclaredClasses = $currentDeclaredClasses;
 
        return $diff;
    }
 
    protected function handleVirtualClasses($inputModules, InputInterface $input, OutputInterface $output)
    {
        // init new classes by event
        $event = new \Bitrix\Main\Event("main", "onVirtualClassBuildList", [], $inputModules);
        $event->send();
 
        // no need to handle event result, get classes from the memory
        $classes = $this->getDeclaredClassesDiff();
 
        $this->handleClasses($classes, $input, $output);
    }
 
    public static function scalarFieldToTypeHint($field)
    {
        if (is_string($field))
        {
            $fieldClass = $field;
        }
        else
        {
            $fieldClass = get_class($field);
        }
 
        switch ($fieldClass)
        {
            case DateField::class:
                return '\\'.Date::class;
            case DatetimeField::class:
                return '\\'.DateTime::class;
            case IntegerField::class:
                return '\\int';
            case BooleanField::class:
                return '\\boolean';
            case FloatField::class:
                return '\\float';
            case ArrayField::class:
                return 'array';
            default:
                return '\\string';
        }
    }
 
    protected function debug(OutputInterface $output, $message)
    {
        if ($this->debug)
        {
            $output->writeln($message);
        }
    }
}