Karma\Configuration\Parser

Complexity

Total Complexity

45

Size/Duplication

Total Lines	296
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

99.21%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	setEOL()	0	6	1
A	enableIncludeSupport()	0	9	2
A	enableExternalSupport()	0	9	2
A	enableGroupSupport()	0	9	2
A	parse()	0	20	2
A	parseFromMasterFile()	0	21	4
A	readFile()	0	30	4
A	extractLines()	0	21	3
A	trimLines()	0	4	1
A	changeCurrentFile()	0	9	2
A	extractSectionName()	0	12	2
A	switchSectionParser()	0	9	2
A	getVariables()	0	4	1
A	getFileSystem()	0	4	1
A	getExternalVariables()	0	11	2
A	printExternalFilesStatus()	0	15	3
A	getExternalFilesStatus()	0	11	2
A	getGroups()	0	11	2
A	postParse()	0	7	2
A	isSystem()	0	12	2
A	getDefaultEnvironmentsForGroups()	0	11	2

<?php

declare(strict_types = 1);

namespace Karma\Configuration;

use Gaufrette\Filesystem;
use Karma\Configuration\Parser\NullParser;
use Karma\Configuration\Parser\IncludeParser;
use Karma\Configuration\Parser\VariableParser;
use Karma\Configuration\Parser\ExternalParser;
use Psr\Log\NullLogger;
use Karma\Configuration\Parser\GroupParser;

class Parser implements FileParser
{
    use \Karma\Logging\LoggerAware;

    const
        INCLUDES = 'includes',
        VARIABLES = 'variables',
        EXTERNALS = 'externals',
        GROUPS = 'groups';

    private
        $parsers,

It is generally advisable to only define one property per statement.

        $currentParser,
        $parsedFiles,
        $fs,
        $eol;

    public function __construct(Filesystem $fs)
    {
        $this->logger = new NullLogger();

        $this->parsers = array(
            self::VARIABLES => new VariableParser(),
        );

        $this->parsedFiles = array();
        $this->fs = $fs;
        $this->eol = "\n";
    }

    public function setEOL(string $eol): self
    {
        $this->eol = $eol;

        return $this;
    }

    public function enableIncludeSupport(): self
    {
        if(! isset($this->parsers[self::INCLUDES]))
        {
            $this->parsers[self::INCLUDES] = new IncludeParser();
        }

        return $this;
    }

    public function enableExternalSupport(): self
    {
        if(! isset($this->parsers[self::EXTERNALS]))
        {
            $this->parsers[self::EXTERNALS] = new ExternalParser(new Parser($this->fs));
        }

        return $this;
    }

    public function enableGroupSupport(): self
    {
        if(! isset($this->parsers[self::GROUPS]))
        {
            $this->parsers[self::GROUPS] = new GroupParser();
        }

        return $this;
    }

    public function parse(string $masterFilePath): array
    {
        try
        {
            $this->parseFromMasterFile($masterFilePath);

            $variables = $this->getVariables();
            $this->printExternalFilesStatus();

            $this->postParse();

            return $variables;
        }
        catch(\RuntimeException $e)
        {
            $this->error($e->getMessage());

            throw $e;
        }
    }

    private function parseFromMasterFile(string $masterFilePath): void
    {
        $files = array($masterFilePath);

        while(! empty($files))
        {
            foreach($files as $file)
            {
                $this->readFile($file);
            }

            if(isset($this->parsers[self::INCLUDES]))
            {
                $includeParser = $this->parsers[self::INCLUDES];
                $files = $includeParser->getCollectedFiles();

The method getCollectedFiles does only exist in Karma\Configuration\Parser\IncludeParser, but not in Karma\Configuration\Parser\ExternalParser and Karma\Configuration\Parser\GroupParser and Karma\Configuration\Parser\VariableParser.

            }

            // Avoid loop
            $files = array_diff($files, $this->parsedFiles);
        }
    }

    private function readFile(string $filePath): void
    {
        $lines = $this->extractLines($filePath);
        $this->changeCurrentFile($filePath);

        $this->currentParser = new NullParser();
        $currentLineNumber = 0;

        foreach($lines as $line)
        {
            $currentLineNumber++;

            if(empty($line))
            {
                continue;
            }

            $sectionName = $this->extractSectionName($line);
            if($sectionName !== null)
            {
                $this->switchSectionParser($sectionName);

                continue;
            }

            $this->currentParser->parse($line, $currentLineNumber);
        }

        $this->parsers[self::VARIABLES]->endOfFileCheck();

The method endOfFileCheck does only exist in Karma\Configuration\Parser\VariableParser, but not in Karma\Configuration\Parser\ExternalParser and Karma\Configuration\Parser\GroupParser and Karma\Configuration\Parser\IncludeParser.

    }

    private function extractLines(string $filePath): array
    {
        if(! $this->fs->has($filePath))
        {
            throw new \RuntimeException("$filePath does not exist");
        }

        $content = $this->fs->read($filePath);

        $lines = explode($this->eol, $content ?? '');
        $lines = $this->trimLines($lines);

        $this->parsedFiles[] = $filePath;

        if(empty($lines))
        {
            $this->warning("Empty file ($filePath)");
        }

        return $lines;
    }

    private function trimLines(array $lines): array
    {
        return array_map('trim', $lines);
    }

    private function changeCurrentFile(string $filePath): void
    {
        $this->info("Reading $filePath");

        foreach($this->parsers as $parser)
        {
            $parser->setCurrentFile($filePath);
        }
    }

    private function extractSectionName(string $line): ?string
    {
        $sectionName = null;

        // [.*]
        if(preg_match('~^\[(?P<groupName>[^\]]+)\]$~', $line, $matches))
        {
            $sectionName = trim(strtolower($matches['groupName']));
        }

        return $sectionName;
    }

    private function switchSectionParser(string $sectionName): void
    {
        if(! isset($this->parsers[$sectionName]))
        {
            throw new \RuntimeException('Unknown section name ' . $sectionName);
        }

        $this->currentParser = $this->parsers[$sectionName];
    }

    public function getVariables(): array
    {
        return $this->parsers[self::VARIABLES]->getVariables();

The method getVariables does only exist in Karma\Configuration\Parser\VariableParser, but not in Karma\Configuration\Parser\ExternalParser and Karma\Configuration\Parser\GroupParser and Karma\Configuration\Parser\IncludeParser.

    }

    public function getFileSystem(): Filesystem
    {
        return $this->fs;
    }

    public function getExternalVariables(): array
    {
        $variables = [];

        if(isset($this->parsers[self::EXTERNALS]))
        {
            $variables = $this->parsers[self::EXTERNALS]->getExternalVariables();

The method getExternalVariables does only exist in Karma\Configuration\Parser\ExternalParser, but not in Karma\Configuration\Parser\GroupParser and Karma\Configuration\Parser\IncludeParser and Karma\Configuration\Parser\VariableParser.

        }

        return $variables;
    }

    private function printExternalFilesStatus(): void
    {
        $files = $this->getExternalFilesStatus();

        foreach($files as $file => $status)
        {
            if($status['found'] === false)
            {
                $this->warning(sprintf(
                   'External file %s was not found',
                   $file
                ));
            }
        }
    }

    private function getExternalFilesStatus(): array
    {
        $files = [];

        if(isset($this->parsers[self::EXTERNALS]))
        {
            $files = $this->parsers[self::EXTERNALS]->getExternalFilesStatus();

The method getExternalFilesStatus does only exist in Karma\Configuration\Parser\ExternalParser, but not in Karma\Configuration\Parser\GroupParser and Karma\Configuration\Parser\IncludeParser and Karma\Configuration\Parser\VariableParser.

        }

        return $files;
    }

    public function getGroups(): array
    {
        $groups = [];

        if(isset($this->parsers[self::GROUPS]))
        {
            $groups = $this->parsers[self::GROUPS]->getCollectedGroups();

The method getCollectedGroups does only exist in Karma\Configuration\Parser\GroupParser, but not in Karma\Configuration\Parser\ExternalParser and Karma\Configuration\Parser\IncludeParser and Karma\Configuration\Parser\VariableParser.

        }

        return $groups;
    }

    private function postParse(): void
    {
        foreach($this->parsers as $parser)
        {
            $parser->postParse();
        }
    }

    public function isSystem(string $variableName): bool
    {
        $system = false;

        $variables = $this->getVariables();
        if(isset($variables[$variableName]))
        {
            $system = $variables[$variableName]['system'];
        }

        return $system;
    }

    public function getDefaultEnvironmentsForGroups(): array
    {
         $defaultEnvironments = [];

        if(isset($this->parsers[self::GROUPS]))
        {
            $defaultEnvironments = $this->parsers[self::GROUPS]->getDefaultEnvironmentsForGroups();

The method getDefaultEnvironmentsForGroups does only exist in Karma\Configuration\Parser\GroupParser, but not in Karma\Configuration\Parser\ExternalParser and Karma\Configuration\Parser\IncludeParser and Karma\Configuration\Parser\VariableParser.

        }

        return $defaultEnvironments;
    }
}