Yoanm\DefaultPhpRepository\Processor\InitCommandProcessor

Complexity

Total Complexity

22

Size/Duplication

Total Lines	143
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	21	1
C	process()	0	39	11
A	displayTemplate()	0	6	1
A	dumpTemplate()	0	8	2
B	validateDump()	0	21	6
A	doOverwrite()	0	4	1

<?php
namespace Yoanm\DefaultPhpRepository\Processor;

use Symfony\Component\Console\Helper\QuestionHelper;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Question\ConfirmationQuestion;
use Symfony\Component\Filesystem\Filesystem;
use Yoanm\DefaultPhpRepository\Helper\PathHelper;
use Yoanm\DefaultPhpRepository\Helper\TemplateHelper;
use Yoanm\DefaultPhpRepository\Model\FolderTemplate;
use Yoanm\DefaultPhpRepository\Model\Template;

/**
 * Class InitCommandProcessor
 */
class InitCommandProcessor extends CommandProcessor
{
    /** @var TemplateHelper */
    private $templateHelper;
    /** @var Filesystem */
    private $fileSystem;
    /** @var string */
    private $rootPath;
    /** @var bool */
    private $skipExisting;
    /** @var bool */
    private $forceOverride;
    /** @var array */
    private $idList = [];

    /**
     * @param QuestionHelper     $questionHelper
     * @param InputInterface     $input
     * @param OutputInterface    $output
     * @param TemplateHelper     $templateHelper
     * @param Template[]         $templateList
     * @param bool               $skipExisting
     * @param bool               $forceOverride
     * @param array              $idList
     */
    public function __construct(
        QuestionHelper $questionHelper,
        InputInterface $input,
        OutputInterface $output,
        TemplateHelper $templateHelper,
        array $templateList,
        $skipExisting = true,
        $forceOverride = false,
        $idList = [],
        $rootPath = '.'
    ) {
        parent::__construct($questionHelper, $input, $output, $templateList);

        $this->templateHelper = $templateHelper;
        $this->rootPath = realpath($rootPath);
        $this->fileSystem = new Filesystem();

        $this->skipExisting = $skipExisting;
        $this->forceOverride = $forceOverride;
        $this->idList = $idList;
    }

    public function process()
    {
        $currentType = null;
        foreach ($this->getTemplateList() as $template) {
            if (count($this->idList) && !in_array($template->getId(), $this->idList)) {
                continue;
            }
            $this->displayHeader($template, $currentType);

            $currentType = $this->resolveCurrentType($template);
            $fileExist = false;
            if ($template instanceof FolderTemplate) {
                $this->displayTemplate($template);
                foreach ($template->getFileList() as $subTemplate) {
                    $targetPath = sprintf('%s/%s', $this->rootPath, $subTemplate->getTarget());
                    list($fileExist, $process) = $this->validateDump($targetPath);
                    if (false === $process) {
                        break;
                    }
                }
                if (true === $process) {

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

                    foreach ($template->getFileList() as $subTemplate) {
                        $targetPath = sprintf('%s/%s', $this->rootPath, $subTemplate->getTarget());
                        $this->dumpTemplate($subTemplate, $targetPath);
                    }
                }
            } else {
                $this->displayTemplate($template);
                $targetPath = sprintf('%s/%s', $this->rootPath, $template->getTarget());
                list($fileExist, $process) = $this->validateDump($targetPath);
                if (true === $process) {
                    $this->dumpTemplate($template, $targetPath);
                }
            }
            if (false === $fileExist) {
                $this->display('<info>Done</info>');
            }
        }
    }

    /**
     * @param Template $template
     */
    protected function displayTemplate(Template $template)
    {
        $this->display(sprintf('<comment>%s</comment>', $template->getId()), 2, false);
        $targetRelativePath = sprintf('./%s', $template->getTarget());
        $this->display(sprintf(' - <info>%s</info> : ', $targetRelativePath), 0, false);
    }

    /**
     * @param Template $template
     * @param string           $path
     */
    protected function dumpTemplate(Template $template, $path)
    {
        $templateId = $template->getSource();
        if (null !== $template->getNamespace()) {
            $templateId = sprintf('@%s/%s', $template->getNamespace(), $template->getSource());
        }
        $this->templateHelper->dumpTemplate($templateId, $path);
    }

    /**
     * @param string $target
     * @return array
     */
    protected function validateDump($target)
    {
        $fileExist = $this->fileSystem->exists($target);
        $process = true;
        if ($fileExist) {
            if (false === $this->forceOverride && true === $this->skipExisting) {
                $this->display('<comment>Skipped !</comment>');
                $process = false;
            } else {
                $process = false;
                if (true === $this->forceOverride) {
                    $this->display('<comment>Overriden !</comment>');
                    $process = true;
                } elseif ($this->doOverwrite()) {
                    $process = true;
                }
            }
        }

        return [$fileExist, $process];
    }

    /**@return bool
     */
    protected function doOverwrite()
    {
        return $this->ask(new ConfirmationQuestion('<question>Overwrite ? [n]</question>', false));
    }
}