Karma\Hydrator

Complexity

Total Complexity

69

Size/Duplication

Total Lines	480
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

99.09%

Importance

Changes

0

33 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	27	2
A	setSuffix()	0	6	1
A	setDryRun()	0	6	1
A	enableBackup()	0	6	1
A	allowNonDistFilesOverwrite()	0	6	1
A	setFormatterProvider()	0	6	1
A	setSystemEnvironment()	0	6	1
A	hydrate()	0	19	3
A	collectFiles()	0	6	1
A	copyNonDistFiles()	0	9	2
A	collectNonDistFiles()	0	6	1
A	hydrateFile()	0	32	5
A	hasBeenHydrated()	0	4	1
A	parseFileDirectives()	0	11	1
A	parseListDirective()	0	35	4
A	lookingForSyntaxErrorInListDirective()	0	8	2
A	generateContentForListDirective()	0	22	4
A	removeFileDirectives()	0	4	1
A	injectValues()	0	12	2
A	readValueToInject()	0	15	3
A	getFormatterForCurrentTargetFile()	0	6	1
A	detectEol()	0	14	3
A	backupFile()	0	11	3
A	rollback()	0	9	2
A	rollbackFile()	0	18	3
A	getUnusedVariables()	0	4	1
A	markVariableAsUsed()	0	7	2
A	getUnvaluedVariables()	0	4	1
A	hydratedFiles()	0	4	1
A	parseFormatterDirective()	0	16	3
A	checkValueIsAllowed()	0	16	3
A	injectScalarValues()	0	20	2
B	injectListValues()	0	45	6

<?php

declare(strict_types = 1);

namespace Karma;

use Gaufrette\Filesystem;
use Psr\Log\NullLogger;
use Karma\FormatterProviders\NullProvider;

class Hydrator implements ConfigurableProcessor
{
    use \Karma\Logging\LoggerAware;

    const
        TODO_VALUE = '__TODO__',
        FIXME_VALUE = '__FIXME__',
        VARIABLE_REGEX = '~<%(?P<variableName>[A-Za-z0-9_\.\-]+)%>~';

    private
        $sources,
        $suffix,
        $reader,
        $dryRun,
        $enableBackup,
        $finder,
        $formatterProvider,
        $currentFormatterName,
        $currentTargetFile,
        $systemEnvironment,
        $unusedVariables,
        $unvaluedVariables,
        $target,
        $nonDistFilesOverwriteAllowed,
        $hydratedFiles;

    public function __construct(Filesystem $sources, Filesystem $target, Configuration $reader, Finder $finder, FormatterProvider $formatterProvider = null)
    {
        $this->logger = new NullLogger();

        $this->sources = $sources;
        $this->target = $target;
        $this->reader = $reader;
        $this->finder = $finder;

        $this->suffix = Application::DEFAULT_DISTFILE_SUFFIX;
        $this->dryRun = false;
        $this->enableBackup = false;

        $this->formatterProvider = $formatterProvider;
        if($this->formatterProvider === null)
        {
            $this->formatterProvider = new NullProvider();
        }

        $this->currentFormatterName = null;
        $this->currentTargetFile = null;
        $this->systemEnvironment = null;
        $this->unusedVariables = array_flip($reader->getAllVariables());
        $this->unvaluedVariables = [];
        $this->nonDistFilesOverwriteAllowed = false;
        $this->hydratedFiles = [];
    }

    public function setSuffix(string $suffix)
    {
        $this->suffix = $suffix;

        return $this;
    }

    public function setDryRun(bool $value = true): ConfigurableProcessor
    {
        $this->dryRun = $value;

        return $this;
    }

    public function enableBackup(bool $value = true): ConfigurableProcessor
    {
        $this->enableBackup = $value;

        return $this;
    }
    
    public function allowNonDistFilesOverwrite(bool $nonDistFilesOverwriteAllowed = true)
    {
        $this->nonDistFilesOverwriteAllowed = $nonDistFilesOverwriteAllowed;

        return $this;
    }

    public function setFormatterProvider(FormatterProvider $formatterProvider)
    {
        $this->formatterProvider = $formatterProvider;

        return $this;
    }

    public function setSystemEnvironment(?string $environment): ConfigurableProcessor
    {
        $this->systemEnvironment = $environment;

        return $this;
    }

    public function hydrate(string $environment): void
    {
        $files = $this->collectFiles();

        foreach($files as $file)
        {
            $this->hydrateFile($file, $environment);
        }

        if($this->nonDistFilesOverwriteAllowed === true)
        {
            $this->copyNonDistFiles();
        }

        $this->info(sprintf(
           '%d files generated',
            count($files)
        ));
    }

    private function collectFiles(): iterable
    {
        $pattern = sprintf('.*%s$', preg_quote($this->suffix, '~'));
        
        return $this->finder->findFiles(sprintf('~%s~', $pattern));
    }
    
    private function copyNonDistFiles(): void
    {
        $filesToCopy = $this->collectNonDistFiles();

        foreach($filesToCopy as $file)
        {
            $this->target->write($file, $this->sources->read($file));

It seems like $this->sources->read($file) targeting Gaufrette\Filesystem::read() can also be of type boolean; however, Gaufrette\Filesystem::write() does only seem to accept string, maybe add an additional type check?

        }
    }
    
    private function collectNonDistFiles(): iterable
    {
        $pattern = sprintf('(?<!%s)$', preg_quote($this->suffix, '~'));
        
        return $this->finder->findFiles(sprintf('~%s~', $pattern));
    }
    

    private function hydrateFile(string $file, string $environment): void
    {
        $this->currentTargetFile = preg_replace(sprintf(
            '~(.*)(%s)$~',
            preg_quote($this->suffix, '~')
        ), '$1', $file);

        if($this->nonDistFilesOverwriteAllowed)
        {
            $this->currentTargetFile = (new \SplFileInfo($this->currentTargetFile))->getFilename();
        }

        $content = (string) $this->sources->read($file);
        $replacementCounter = $this->parseFileDirectives($file, $content, $environment);

        $targetContent = $this->injectValues($file, $content, $environment, $replacementCounter);

        $this->debug("Write $this->currentTargetFile");

        if($this->dryRun === false)
        {
            if($this->hasBeenHydrated($this->currentTargetFile) && $this->nonDistFilesOverwriteAllowed)
            {
                throw new \RuntimeException(sprintf('The fileName "%s" is defined in 2 config folders (not allowed with targetPath config enabled)', $this->currentTargetFile));
            }

            $this->backupFile($this->currentTargetFile);
            $this->target->write($this->currentTargetFile, $targetContent, true);
        }

        $this->hydratedFiles[$this->currentTargetFile] = $replacementCounter;
    }

    private function hasBeenHydrated(string $file): bool
    {
        return array_key_exists($file, $this->hydratedFiles);
    }

    private function parseFileDirectives(string $file, string & $fileContent, string $environment): int
    {
        $this->currentFormatterName = null;

        $this->parseFormatterDirective($file, $fileContent);
        $replacementCounter = $this->parseListDirective($file, $fileContent, $environment);

        $fileContent = $this->removeFileDirectives($fileContent);

        return $replacementCounter;
    }

    private function parseFormatterDirective(string $file, string $fileContent): void
    {
        if($count = preg_match_all('~<%\s*karma:formatter\s*=\s*(?P<formatterName>[^%]+)%>~', $fileContent, $matches))
        {
            if($count !== 1)
            {
                throw new \RuntimeException(sprintf(
                    'Syntax error in %s : only one formatter directive is allowed (%d found)',
                    $file,
                    $count
                ));
            }

            $this->currentFormatterName = strtolower(trim($matches['formatterName'][0]));
        }
    }

    private function parseListDirective(string $file, string & $fileContent, string $environment): int
    {
        $replacementCounter = 0;

        $regexDelimiter = '(delimiter="(?P<delimiterName>[^"]*)")?';
        $regexWrapper = '(wrapper="(?P<wrapperPrefix>[^"]*)":"(?P<wrapperSuffix>[^"]*)")?';
        $regex = '~<%\s*karma:list\s*var=(?P<variableName>[\S]+)\s*' . $regexDelimiter . '\s*' . $regexWrapper . '\s*%>~i';

        while(preg_match($regex, $fileContent, $matches))
        {
            $delimiter = '';
            if(isset($matches['delimiterName']))
            {
                $delimiter = $matches['delimiterName'];
            }

            $wrapper = ['prefix' => '', 'suffix' => ''];
            if(isset($matches['wrapperPrefix'], $matches['wrapperSuffix']))
            {
                $wrapper = [
                    'prefix' => $matches['wrapperPrefix'],
                    'suffix' => $matches['wrapperSuffix']
                ];
            }

            $generatedList = $this->generateContentForListDirective($matches['variableName'], $environment, $delimiter, $wrapper);
            $fileContent = str_replace($matches[0], $generatedList, $fileContent);

            $replacementCounter++;
        }

        $this->lookingForSyntaxErrorInListDirective($file, $fileContent);

        return $replacementCounter;
    }

    private function lookingForSyntaxErrorInListDirective(string $file, string $fileContent): void
    {
        if(preg_match('~<%.*karma\s*:\s*list\s*~i', $fileContent))
        {
            // karma:list detected but has not matches full regexp
            throw new \RuntimeException("Invalid karma:list directive in file $file");
        }
    }

    private function generateContentForListDirective(string $variable, string $environment, string $delimiter, array $wrapper): string
    {
        $values = $this->readValueToInject($variable, $environment);
        $formatter = $this->getFormatterForCurrentTargetFile();

        if(! is_array($values))
        {
            $values = [$values];
        }

        array_walk($values, function (& $value) use ($formatter) {
            $value = $formatter->format($value);
        });

        $generated = implode($delimiter, $values);
        return sprintf(
            '%s%s%s',
            ! empty($generated) ? $wrapper['prefix'] : '',
            $generated,
            ! empty($generated) ? $wrapper['suffix'] : ''
        );
    }

    private function removeFileDirectives($fileContent)
    {
        return preg_replace('~(<%\s*karma:[^%]*%>\s*)~i', '', $fileContent);
    }

    private function injectValues(string $sourceFile, string $content, string $environment, int & $replacementCounter = 0): string
    {
        $replacementCounter += $this->injectScalarValues($content, $environment);
        $replacementCounter += $this->injectListValues($content, $environment);

        if($replacementCounter === 0)
        {
            $this->warning("No variable found in $sourceFile");
        }

        return $content;
    }

    private function readValueToInject(string $variableName, string $environment)
    {
        if($this->systemEnvironment !== null && $this->reader->isSystem($variableName) === true)
        {
            $environment = $this->systemEnvironment;
        }

        $this->markVariableAsUsed($variableName);

        $value = $this->reader->read($variableName, $environment);

        $this->checkValueIsAllowed($variableName, $environment, $value);

        return $value;
    }

    private function checkValueIsAllowed(string $variableName, string $environment, $value): void
    {
        if($value === self::FIXME_VALUE)
        {
            throw new \RuntimeException(sprintf(
                'Missing value for variable %s in environment %s (FIXME marker found)',
                $variableName,
                $environment
            ));
        }

        if($value === self::TODO_VALUE)
        {
            $this->unvaluedVariables[] = $variableName;
        }
    }

    private function getFormatterForCurrentTargetFile(): Formatter
    {
        $fileExtension = pathinfo($this->currentTargetFile, PATHINFO_EXTENSION);

        return $this->formatterProvider->getFormatter($fileExtension, $this->currentFormatterName);
    }

    private function injectScalarValues(string & $content, string $environment): int
    {
        $formatter = $this->getFormatterForCurrentTargetFile();

        $content = preg_replace_callback(self::VARIABLE_REGEX, function(array $matches) use($environment, $formatter)
        {
            $value = $this->readValueToInject($matches['variableName'], $environment);

            if(is_array($value))
            {
                // don't replace lists at this time
                return $matches[0];
            }

            return $formatter->format($value);

        }, $content, -1, $count);

        return $count;
    }

    private function injectListValues(string & $content, string $environment): int
    {
        $formatter = $this->getFormatterForCurrentTargetFile();
        $replacementCounter = 0;

        $eol = $this->detectEol($content);

        while(preg_match(self::VARIABLE_REGEX, $content))
        {
            $lines = explode($eol, $content);
            $result = [];

            foreach($lines as $lineNumber => $line)
            {
                if(preg_match(self::VARIABLE_REGEX, $line, $matches))
                {
                    $values = $this->readValueToInject($matches['variableName'], $environment);

                    if(!is_array($values))
                    {
                        throw new \RuntimeException(sprintf(
                            "Nested variable detected [%s] while writing %s at line %d",
                            $matches['variableName'],
                            $this->currentTargetFile,
                            $lineNumber
                        ));
                    }
                    
                    $replacementCounter++;
                    foreach($values as $value)
                    {
                        $result[] = preg_replace(self::VARIABLE_REGEX, $formatter->format($value), $line, 1);
                    }

                    continue;
                }

                $result[] = $line;
            }

            $content = implode($eol, $result);
        }

        return $replacementCounter;
    }

    private function detectEol(string $content): string
    {
        $types = array("\r\n", "\r", "\n");

        foreach($types as $type)
        {
            if(strpos($content, $type) !== false)
            {
                return $type;
            }
        }

        return "\n";
    }

    private function backupFile(string $targetFile): void
    {
        if($this->enableBackup === true)
        {
            if($this->target->has($targetFile))
            {
                $backupFile = $targetFile . Application::BACKUP_SUFFIX;
                $this->target->write($backupFile, $this->target->read($targetFile), true);

It seems like $this->target->read($targetFile) targeting Gaufrette\Filesystem::read() can also be of type boolean; however, Gaufrette\Filesystem::write() does only seem to accept string, maybe add an additional type check?

            }
        }
    }

    public function rollback(): void
    {
        $files = $this->collectFiles();

        foreach($files as $file)
        {
            $this->rollbackFile($file);
        }
    }

    private function rollbackFile(string $file): void
    {
        $this->debug("- $file");

        $targetFile = substr($file, 0, strlen($this->suffix) * -1);
        $backupFile = $targetFile . Application::BACKUP_SUFFIX;

        if($this->sources->has($backupFile))
        {
            $this->info("  Writing $targetFile");

            if($this->dryRun === false)
            {
                $backupContent = $this->sources->read($backupFile);
                $this->sources->write($targetFile, $backupContent, true);

It seems like $backupContent defined by $this->sources->read($backupFile) on line 462 can also be of type boolean; however, Gaufrette\Filesystem::write() does only seem to accept string, maybe add an additional type check?

            }
        }
    }

    public function getUnusedVariables(): array
    {
        return array_merge(array_flip($this->unusedVariables));
    }

    private function markVariableAsUsed(string $variableName): void
    {
        if(isset($this->unusedVariables[$variableName]))
        {
            unset($this->unusedVariables[$variableName]);
        }
    }

    public function getUnvaluedVariables(): array
    {
        return $this->unvaluedVariables;
    }

    public function hydratedFiles(): array
    {
        return $this->hydratedFiles;
    }
}