Karma\Configuration\Parser\GroupParser

Complexity

Total Complexity

25

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

98.72%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	parseLine()	0	16	3
A	processGroupDefinition()	0	22	3
A	checkForDefaultMarker()	0	31	4
A	checkGroupStillNotExists()	0	7	2
A	checkEnvironmentAreUnique()	0	7	2
A	hasDuplicatedValues()	0	8	1
A	getCollectedGroups()	0	4	1
A	postParse()	0	5	1
A	checkEnvironmentsBelongToOnlyOneGroup()	0	9	2
A	getAllEnvironmentsBelongingToGroups()	0	11	2
A	checkGroupsAreNotPartsOfAnotherGroups()	0	14	2
A	getDefaultEnvironmentsForGroups()	0	4	1

<?php

declare(strict_types = 1);

namespace Karma\Configuration\Parser;

class GroupParser extends AbstractSectionParser
{
    private
        $groups,

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

        $defaultEnvironments;

    public function __construct()
    {
        $this->groups = array();
        $this->defaultEnvironments = array();
    }

    protected function parseLine($line)
    {
        if($this->isACommentLine($line))
        {
            return true;
        }

        $line = trim($line);

        if(preg_match('~(?P<groupName>[^=]+)\s*=\s*\[(?P<envList>[^\[\]]+)\]$~', $line, $matches))
        {
            return $this->processGroupDefinition($matches['groupName'], $matches['envList']);
        }

        $this->triggerError($line);
    }

    private function processGroupDefinition($groupName, $envList)
    {
        $groupName = trim($groupName);

        $this->checkGroupStillNotExists($groupName);

        $environments = array_map('trim', explode(',', $envList));
        $environments = $this->checkForDefaultMarker($groupName, $environments);
        $this->checkEnvironmentAreUnique($groupName, $environments);

        $this->groups[$groupName] = array();

        foreach($environments as $env)
        {
            if(empty($env))
            {
                $this->triggerError("empty environment in declaration of group $groupName");
            }

            $this->groups[$groupName][] = $env;
        }
    }

    private function checkForDefaultMarker($groupName, array $environments)
    {
        $environmentNames = array();
        $this->defaultEnvironments[$groupName] = null;

        foreach($environments as $envString)
        {
            $name = $envString;

            if(preg_match('~\*\s*(?P<envName>.*)~', $envString, $matches))
            {
                $name = $matches['envName'];

                if(isset($this->defaultEnvironments[$groupName]))
                {
                    throw new \RuntimeException(sprintf(
                        'Group %s must have only one default environment : %s and %s are declared as default',
                        $groupName,
                        $this->defaultEnvironments[$groupName],
                        $name
                    ));
                }

                $this->defaultEnvironments[$groupName] = $name;
            }

            $environmentNames[] = $name;
        }

        return $environmentNames;
    }

    private function checkGroupStillNotExists($groupName)
    {
        if(isset($this->groups[$groupName]))
        {
            $this->triggerError("group $groupName has already been declared");
        }
    }

    private function checkEnvironmentAreUnique($groupName, array $environments)
    {
        if($this->hasDuplicatedValues($environments))
        {
            $this->triggerError("duplicated environment in group $groupName");
        }
    }

    private function hasDuplicatedValues(array $values)
    {
        $duplicatedValues = array_filter(array_count_values($values), function ($counter) {
            return $counter !== 1;
        });

        return empty($duplicatedValues) === false;
    }

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

    public function postParse()
    {
        $this->checkEnvironmentsBelongToOnlyOneGroup();
        $this->checkGroupsAreNotPartsOfAnotherGroups();
    }

    private function checkEnvironmentsBelongToOnlyOneGroup()
    {
        $allEnvironments = $this->getAllEnvironmentsBelongingToGroups();

        if($this->hasDuplicatedValues($allEnvironments))
        {
            throw new \RuntimeException('Error : some environments are in various groups');
        }
    }

    private function getAllEnvironmentsBelongingToGroups()
    {
        $allEnvironments = array();

        foreach($this->groups as $group)
        {
            $allEnvironments = array_merge($allEnvironments, $group);
        }

        return $allEnvironments;
    }

    private function checkGroupsAreNotPartsOfAnotherGroups()
    {
        $allEnvironments = $this->getAllEnvironmentsBelongingToGroups();

        $errors = array_intersect($allEnvironments, array_keys($this->groups));

        if(! empty($errors))
        {
            throw new \RuntimeException(sprintf(
               'Error : a group can not be part of another group (%s)',
                implode(', ', $errors)
            ));
        }
    }

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