Addiks\RDMBundle\DataLoader\BlackMagic\BlackMagicEntityCodeGenerator

Complexity

Total Complexity

39

Size/Duplication

Total Lines	228
Duplicated Lines	0 %

Importance

Changes	5
Bugs	5	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	relativePathFromTo()	0	19	2
D	skipIrrelevantCode()	0	37	19
C	processMapping()	0	108	13
A	findClassStartPosition()	0	47	4

<?php
/**
 * Copyright (C) 2019 Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 *
 * @license GPL-3.0
 *
 * @author Gerrit Addiks <gerrit@addiks.de>
 */

namespace Addiks\RDMBundle\DataLoader\BlackMagic;

use Addiks\RDMBundle\Mapping\EntityMappingInterface;
use Composer\Autoload\ClassLoader;
use Webmozart\Assert\Assert;
use Addiks\RDMBundle\Mapping\MappingInterface;
use ErrorException;
use Doctrine\DBAL\Schema\Column;
use Addiks\RDMBundle\DataLoader\BlackMagic\BlackMagicDataLoader;

final class BlackMagicEntityCodeGenerator
{

    public function __construct(
        public readonly string $targetDirectory,
        private BlackMagicDataLoader $dataLoader,
        public readonly string $indenting = "    "
    ) {
    }
    
    public function processMapping(
        EntityMappingInterface $mapping,
        ClassLoader $loader
    ): string|null {
        /** @var array<array-key, Column> $columns */
        $columns = $mapping->collectDBALColumns();
        
        if (empty($columns)) {
            return null;
        }
        
        /** @var string $fullClassName */
        $fullClassName = $mapping->getEntityClassName();
        
        /** @var string|false $filePath */
        $filePath = $loader->findFile($fullClassName);
        
        if ($filePath === false) {
            return null;
        }

        /** @var array<string, bool> $walkedFiles */
        $walkedFiles = [$filePath => true];
        
        /** @var string $safeFilePath */
        $safeFilePath = $filePath;

        do {
            if (!file_exists($filePath)) {
                $filePath = $safeFilePath;
                break;
            }
            
            /** @var string $entityPHP */
            $entityPHP = file_get_contents($filePath);

            if (1 === preg_match("#\/\*\* \@addiks-original-file ([^\*]*) \*\/#is", $entityPHP, $matches)) {
                $safeFilePath = $filePath;
                $filePath = trim($matches[1]);

                if (!file_exists($filePath)) {
                    /** @var string $relativePath */
                    $relativePath = dirname($safeFilePath) . '/' . $filePath;

                    if (file_exists($relativePath)) {
                        $filePath = realpath($relativePath);
                    }
                }

                if (isset($walkedFiles[$filePath])) {
                    break; # Circular reference detected
                }
                $walkedFiles[$filePath] = true;
                continue;
            }
            break;
        } while (true);
        
        /** @var int $classStartPosition */
        $classStartPosition = self::findClassStartPosition($fullClassName, $entityPHP);

The variable $entityPHP does not seem to be defined for all execution paths leading up to this point.

        
        /** @var array<string, Column> $writtenFieldNames */
        $writtenFieldNames = array();
        
        foreach ($columns as $column) {
            
            /** @var string $fieldName */
            $fieldName = $this->dataLoader->columnToFieldName($column);
            
            /** @var string $fieldPHP */
            $fieldPHP = sprintf(
                "\n%spublic $%s;\n",
                $this->indenting,
                $fieldName
            );
            
            if (isset($writtenFieldNames[$fieldName]) || str_contains($entityPHP, $fieldPHP)) {
                continue;
            }

            $writtenFieldNames[$fieldName] = $column;

            $entityPHP = sprintf(
                '%s%s%s',
                substr($entityPHP, 0, $classStartPosition),
                $fieldPHP,
                substr($entityPHP, $classStartPosition)
            );
        }
        
        $targetFilePath = sprintf(
            '%s/%s.php',
            $this->targetDirectory,
            str_replace('\\', '_', $fullClassName)
        );
        
        $entityPHP .= sprintf(
            "\n\n/** @addiks-original-file %s */\n",
            self::relativePathFromTo($targetFilePath, realpath($filePath))
        );

        if (!is_dir($this->targetDirectory)) {
            mkdir($this->targetDirectory, 0777, true);
        }
        
        file_put_contents($targetFilePath, $entityPHP);
        
        return $targetFilePath;
    }
    
    private static function relativePathFromTo(string $originPath, string $targetPath): string
    {
        /** @var array<int, string> $originPathSteps */
        $originPathSteps = explode('/', $originPath);

        /** @var mixed $targetPathSteps */
        $targetPathSteps = explode('/', $targetPath);

        while ($originPathSteps[0] === $targetPathSteps[0]) {
            array_shift($originPathSteps);
            array_shift($targetPathSteps);
        }

        $relativePathSteps = array_merge(
            array_pad([], count($originPathSteps) - 1, '..'),
            $targetPathSteps
        );

        return implode('/', $relativePathSteps);
    }

    private static function findClassStartPosition(
        string $fullClassName, 
        string $entityPHP
    ): int {
        
        /** @var int|null|false $classStartPosition */
        $classStartPosition = null;

The assignment to $classStartPosition is dead and can be removed.

        
        /** @var int $position */
        $position = 0;
        
        /** @var array<int, string> $namespacePath */
        $namespacePath = explode("\\", $fullClassName);
        
        /** @var string $className */
        $className = array_pop($namespacePath);
        
        /** @var string $pattern */
        $pattern = sprintf(
            '/^(interface|trait|class)\s+%s\W*/is',
            $className
        );
        
        /** @var int $codeLength */
        $codeLength = strlen($entityPHP);
        
        do {
            if (preg_match($pattern, substr($entityPHP, $position, 128))) {
                $classStartPosition = strpos($entityPHP, '{', $position);
                
                if (is_int($classStartPosition)) {
                    return $classStartPosition + 1;

                } else {
                    $classStartPosition = null;
                }
            }
            
            self::skipIrrelevantCode($entityPHP, $position);
            
            $position++;
        } while ($position < $codeLength);
        
        throw new ErrorException(sprintf(
            'Could not find start position of class "%s" if file "%s"!',
            $fullClassName,
            $entityPHP
        ));
    }
    
    private static function skipIrrelevantCode(string $phpCode, int &$position): void
    {
        /** @var int $codeLength */
        $codeLength = strlen($phpCode);
        
        if (substr($phpCode, $position, 2) === '/*') {
            do {
                $position++;
            } while (substr($phpCode, $position, 2) !== '*/' && $position < $codeLength);
            
        } elseif (substr($phpCode, $position, 2) === '//') {
            do {
                $position++;
            } while ($phpCode[$position] !== "\n" && $position < $codeLength);
            
        } elseif (substr($phpCode, $position, 3) === '<<<') {
            $position += 3;
            $eofFlag = "";
            do {
                $eofFlag .= $phpCode[$position];
                $position++;
            } while ($phpCode[$position] !== "\n");
            
            do {
                $position++;
                $charsAtPosition = substr($phpCode, $position, strlen($eofFlag) + 1);
            } while ($charsAtPosition !== $eofFlag . ';' && $position < $codeLength);
            
        } elseif ($phpCode[$position] === '"') {
            do {
                $position++;
            } while ($phpCode[$position] !== '"' && $phpCode[$position - 1] !== '\\' && $position < $codeLength);

        } elseif ($phpCode[$position] === "'") {
            do {
                $position++;
            } while ($phpCode[$position] !== "'" && $phpCode[$position - 1] !== '\\' && $position < $codeLength);
        }
    }
    
}