Karma\Configuration\Parser

Complexity

Total Complexity

41

Size/Duplication

Total Lines	276
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

99.2%

Importance

Changes

0

22 Methods

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

<?php

declare(strict_types = 1);

namespace Karma\Configuration;

use Gaufrette\Filesystem;
use Karma\Configuration\Collections\SectionParserCollection;
use Karma\Configuration\Parser\NullParser;
use Psr\Log\NullLogger;

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

    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 = new SectionParserCollection();

        $this->parsedFiles = [];
        $this->fs = $fs;
        $this->eol = "\n";
    }

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

        return $this;
    }

    public function enableIncludeSupport(): self
    {
        $this->parsers->enableIncludeSupport();

        return $this;
    }

    public function enableExternalSupport(): self
    {
       $this->parsers->enableExternalSupport($this->fs);

        return $this;
    }

    public function enableGroupSupport(): self
    {
        $this->parsers->enableGroupSupport();

        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 = [$masterFilePath];

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

            $parser = $this->parsers->includes();
            if($parser !== null)
            {
                $files = $parser->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 parseFile(string $filePath): void
    {
        $this->parsedFiles[] = $filePath;
        $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->variables()->endOfFileCheck();
    }

    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);

        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<sectionName>[^\]]+)\]$~', $line, $matches))
        {
            $sectionName = strtolower(trim($matches['sectionName']));
        }

        return $sectionName;
    }

    private function switchSectionParser(string $sectionName): void
    {
        $this->currentParser = $this->parsers->get($sectionName);
    }

    public function getVariables(): array
    {
        return $this->parsers->variables()->getVariables();
    }

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

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

        $parser = $this->parsers->externals();
        if($parser !== null)
        {
            $variables = $parser->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 = [];

        $parser = $this->parsers->externals();
        if($parser !== null)
        {
            $files = $parser->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 = [];

        $parser = $this->parsers->groups();
        if($parser !== null)
        {
            $groups = $parser->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 = [];

        $parser = $this->parsers->groups();
        if($parser !== null)
        {
            $defaultEnvironments = $parser->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;
    }
}