EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\Relations\GenerateRelationCodeForEntity

Complexity

Total Complexity

18

Size/Duplication

Total Lines	282
Duplicated Lines	0 %

Test Coverage

Coverage

94.69%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	processPaths()	0	14	4
A	copyRelationsTemplateToDestinationDirectory()	0	6	1
B	initialiseVariables()	0	27	1
A	performFindAndReplaceInFile()	0	21	1
A	renamePathsForCreatedFiles()	0	7	2
A	__construct()	0	18	1
A	renameDirectories()	0	11	3
A	updateNamespace()	0	8	2
A	__invoke()	0	14	2
A	setDestinationDirectory()	0	16	1

<?php declare(strict_types=1);

namespace EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\Relations;

use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\CodeHelper;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\AbstractGenerator;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\FindAndReplaceHelper;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\Generator\RelationsGenerator;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\PathHelper;
use EdmondsCommerce\DoctrineStaticMeta\Exception\DoctrineStaticMetaException;
use EdmondsCommerce\DoctrineStaticMeta\MappingHelper;

class GenerateRelationCodeForEntity
{
    /**
     * @var NamespaceHelper
     */
    protected $namespaceHelper;
    /**
     * @var PathHelper
     */
    protected $pathHelper;
    /**
     * @var FindAndReplaceHelper
     */
    protected $findAndReplaceHelper;
    /**
     * @var string
     */
    protected $projectRootNamespace;
    /**
     * @var string
     */
    private $entityFqn;
    /**
     * @var string
     */
    private $pathToProjectRoot;
    /**
     * @var string
     */
    private $srcSubFolderName;
    /**
     * @var CodeHelper
     */
    private $codeHelper;
    /**
     * @var string
     */
    private $destinationDirectory;
    /**
     * @var string
     */
    private $singularNamespace;
    /**
     * @var string
     */
    private $pluralNamespace;
    /**
     * @var string
     */
    private $singularNamespacedName;
    /**
     * @var string
     */
    private $pluralNamespacedName;
    /**
     * @var array
     */
    private $dirsToRename;
    /**
     * @var array
     */
    private $filesCreated;


    public function __construct(
        string $entityFqn,
        string $pathToProjectRoot,
        string $projectRootNamespace,
        string $srcSubFolderName,
        CodeHelper $codeHelper,
        NamespaceHelper $namespaceHelper,
        PathHelper $pathHelper,
        FindAndReplaceHelper $findAndReplaceHelper
    ) {
        $this->entityFqn            = $entityFqn;
        $this->pathToProjectRoot    = $pathToProjectRoot;
        $this->projectRootNamespace = $projectRootNamespace;
        $this->srcSubFolderName     = $srcSubFolderName;
        $this->codeHelper           = $codeHelper;
        $this->namespaceHelper      = $namespaceHelper;
        $this->pathHelper           = $pathHelper;
        $this->findAndReplaceHelper = $findAndReplaceHelper;
    }

    /**
     * Calculate and set the destination full path to the destination directory for the generated relations files
     *
     * @param string $className
     * @param array  $subDirsNoEntities
     *
     * @return void
     */
    private function setDestinationDirectory(
        string $className,
        array $subDirsNoEntities
    ): void {

        $subDirsNoEntities = \array_slice($subDirsNoEntities, 2);

        $this->destinationDirectory = $this->codeHelper->resolvePath(
            $this->pathToProjectRoot
            .'/'.$this->srcSubFolderName
            .AbstractGenerator::ENTITY_RELATIONS_FOLDER_NAME
            .\implode(
                '/',
                $subDirsNoEntities
            )
            .'/'.$className
        );
    }

    /**
     * Copy all the relations code templates into the destination directory read for processing
     *
     * @throws DoctrineStaticMetaException
     */
    private function copyRelationsTemplateToDestinationDirectory(): void
    {
        $this->pathHelper->copyTemplateDirectoryAndGetPath(
            $this->pathToProjectRoot,
            AbstractGenerator::RELATIONS_TEMPLATE_PATH,
            $this->destinationDirectory
        );
    }

    /**
     * Perform the find and replace operations on the specified file
     *
     * @param string $path
     */
    private function performFindAndReplaceInFile(
        string $path
    ): void {
        $this->findAndReplaceHelper->findReplace(
            'use '.RelationsGenerator::FIND_ENTITIES_NAMESPACE.'\\'.RelationsGenerator::FIND_ENTITY_NAME,
            "use {$this->entityFqn}",
            $path
        );
        $this->findAndReplaceHelper->findReplaceRegex(
            '%use(.+?)Relations\\\TemplateEntity(.+?);%',
            'use ${1}Relations\\'.$this->singularNamespace.'${2};',
            $path
        );
        $this->findAndReplaceHelper->findReplaceRegex(
            '%use(.+?)Relations\\\TemplateEntity(.+?);%',
            'use ${1}Relations\\'.$this->pluralNamespace.'${2};',
            $path
        );
        $this->findAndReplaceHelper->replaceName($this->singularNamespacedName, $path);
        $this->findAndReplaceHelper->replacePluralName($this->pluralNamespacedName, $path);
        $this->findAndReplaceHelper->replaceProjectNamespace($this->projectRootNamespace, $path);
    }

    /**
     * Loop through the created files and rename the paths
     *
     * @throws DoctrineStaticMetaException
     */
    private function renamePathsForCreatedFiles(): void
    {
        foreach ($this->filesCreated as $key => $realPath) {
            $this->filesCreated[$key] = $this->pathHelper->renamePathBasenameSingularOrPlural(
                $realPath,
                $this->singularNamespacedName,
                $this->pluralNamespacedName
            );
        }
    }

    /**
     * Initialise the values for all requires variable
     * @SuppressWarnings(PHPMD.StaticAccess)
     *
     * @throws DoctrineStaticMetaException
     */
    private function initialiseVariables(): void
    {
        list($className, , $subDirs) = $this->namespaceHelper->parseFullyQualifiedName(
            $this->entityFqn,
            $this->srcSubFolderName,
            $this->projectRootNamespace
        );

        $this->singularNamespacedName = $this->namespaceHelper->getSingularNamespacedName(
            $this->entityFqn,
            $subDirs
        );
        $this->pluralNamespacedName   = $this->namespaceHelper->getPluralNamespacedName(
            $this->entityFqn,
            $subDirs
        );
        $this->setDestinationDirectory(
            $className,
            $subDirs
        );
        $plural                  = \ucfirst(MappingHelper::getPluralForFqn($this->entityFqn));
        $singular                = \ucfirst(MappingHelper::getSingularForFqn($this->entityFqn));
        $nsNoEntities            = \implode('\\', \array_slice($subDirs, 2));
        $this->singularNamespace = \ltrim($nsNoEntities.'\\'.$singular, '\\');
        $this->pluralNamespace   = \ltrim($nsNoEntities.'\\'.$plural, '\\');
        $this->dirsToRename      = [];
        $this->filesCreated      = [];
    }

    /**
     * Loop through the iterator paths and process each item
     *
     * @param \Generator $relativePathRelationsGenerator
     */
    private function processPaths(\Generator $relativePathRelationsGenerator): void
    {
        foreach ($relativePathRelationsGenerator as $path => $fileInfo) {
            $fullPath = $this->destinationDirectory."/$path";
            $path     = \realpath($fullPath);
            if (false === $path) {
                throw new \RuntimeException("path $fullPath does not exist");
            }
            if ($fileInfo->isDir()) {
                $this->dirsToRename[] = $path;
                continue;
            }
            $this->performFindAndReplaceInFile($path);
            $this->filesCreated[] = $path;
        }
    }

    /**
     * Loop through all the directories to rename and then rename them
     *
     * @throws DoctrineStaticMetaException
     */
    private function renameDirectories(): void
    {
        //update directory names and update file created paths accordingly
        foreach ($this->dirsToRename as $dirPath) {
            $updateDirPath = $this->pathHelper->renamePathBasenameSingularOrPlural(
                $dirPath,
                $this->singularNamespacedName,
                $this->pluralNamespacedName
            );
            foreach ($this->filesCreated as $k => $filePath) {
                $this->filesCreated[$k] = \str_replace($dirPath, $updateDirPath, $filePath);
            }
        }
    }

    /**
     * Update the namespace in all the created files
     *
     * @throws DoctrineStaticMetaException
     */
    private function updateNamespace()
    {
        //now path is totally sorted, update namespace based on path
        foreach ($this->filesCreated as $filePath) {
            $this->findAndReplaceHelper->setNamespaceFromPath(
                $filePath,
                $this->srcSubFolderName,
                $this->projectRootNamespace
            );
        }
    }

    /**
     * @param \Generator $relativePathRelationsGenerator
     *
     * @throws DoctrineStaticMetaException
     */
    public function __invoke(\Generator $relativePathRelationsGenerator)
    {
        try {
            $this->initialiseVariables();
            $this->copyRelationsTemplateToDestinationDirectory();
            $this->processPaths($relativePathRelationsGenerator);
            $this->renamePathsForCreatedFiles();
            $this->renameDirectories();
            $this->updateNamespace();
        } catch (\Exception $e) {
            throw new DoctrineStaticMetaException(
                'Exception generating relation for entity '.$this->entityFqn.': '.$e->getMessage(),
                $e->getCode(),
                $e
            );
        }
    }
}