Groundskeeper\Configuration

Complexity

Total Complexity

16

Size/Duplication

Total Lines	163
Duplicated Lines	23.31 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	has()	0	4	1
A	get()	0	8	2
A	isAllowedElement()	10	10	2
A	isAllowedType()	10	10	2
B	configureOptions()	18	94	6
A	setDependentOptions()	0	6	2

<?php

namespace Groundskeeper;

use Groundskeeper\Tokens\Element;
use Groundskeeper\Tokens\Token;
use Symfony\Component\OptionsResolver\Options;
use Symfony\Component\OptionsResolver\OptionsResolver;

class Configuration
{
    const CLEAN_STRATEGY_NONE       = 'none';
    const CLEAN_STRATEGY_LENIENT    = 'lenient';
    const CLEAN_STRATEGY_STANDARD   = 'standard';
    const CLEAN_STRATEGY_AGGRESSIVE = 'aggressive';

    const OUTPUT_COMPACT = 'compact';
    const OUTPUT_PRETTY  = 'pretty';

    /** @var array */
    private $options;

    /**
     * Constructor
     */
    public function __construct(array $options = array())
    {
        $resolver = new OptionsResolver();
        $this->configureOptions($resolver);

        $this->options = $resolver->resolve($options);
        $this->setDependentOptions();
    }

    public function has(string $key) : bool
    {
        return array_key_exists($key, $this->options);
    }

    public function get(string $key)
    {
        if (!$this->has($key)) {
            throw new \InvalidArgumentException('Invalid configuration key: ' . $key);
        }

        return $this->options[$key];
    }

    public function isAllowedElement($element)

This method seems to be duplicated in your project.

    {
        if ($element instanceof Element) {
            $element = $element->getName();
        }

        $disallowedElementArray = explode(',', $this->options['element-blacklist']);

        return !in_array($element, $disallowedElementArray);
    }

    public function isAllowedType($type)

This method seems to be duplicated in your project.

    {
        if ($type instanceof Token) {
            $type = $type->getType();
        }

        $disallowedTypeArray = explode(',', $this->options['type-blacklist']);

        return !in_array($type, $disallowedTypeArray);
    }

    protected function configureOptions(OptionsResolver $resolver)
    {
        // Set default options.
        $resolver->setDefaults(array(
            'clean-strategy' => self::CLEAN_STRATEGY_STANDARD,
            'element-blacklist' => '',
            'indent-spaces' => 4,
            'output' => self::OUTPUT_COMPACT,
            'type-blacklist' => Token::CDATA . ',' . Token::COMMENT
        ));

        // Validation

        // clean-strategy
        $resolver->setAllowedTypes('clean-strategy', 'string');
        $resolver->setAllowedValues(
            'clean-strategy',
            array(
                self::CLEAN_STRATEGY_NONE,
                self::CLEAN_STRATEGY_LENIENT,
                self::CLEAN_STRATEGY_STANDARD,
                self::CLEAN_STRATEGY_AGGRESSIVE
            )
        );

        // element-blacklist
        $resolver->setAllowedTypes('element-blacklist', 'string');
        $resolver->setNormalizer(
            'element-blacklist',
            function (Options $options, $value) {

This code seems to be duplicated across your project.

                $valueArray = explode(',', $value);
                $formattedValueArray = array();
                foreach ($valueArray as $data) {
                    $formattedValueArray[] = trim(strtolower($data));
                }

                return implode(',', $formattedValueArray);
            }
        );

        // indent-spaces
        $resolver->setAllowedTypes('indent-spaces', 'int');
        $resolver->setAllowedValues('indent-spaces', function ($value) {
                return $value >= 0;
            }
        );

        // output
        $resolver->setAllowedTypes('output', 'string');
        $resolver->setAllowedValues(
            'output',
            array(self::OUTPUT_COMPACT, self::OUTPUT_PRETTY)
        );

        // type-blacklist
        $resolver->setAllowedTypes('type-blacklist', 'string');
        $resolver->setAllowedValues(
            'type-blacklist',
            function ($value) {
                if ($value == '') {
                    return true;
                }

                $acceptedValues = array(
                    Token::CDATA,
                    Token::COMMENT,
                    Token::DOCTYPE,
                    Token::ELEMENT,
                    Token::PHP,
                    Token::TEXT
                );
                $valueArray = explode(',', $value);
                foreach ($valueArray as $val) {
                    if (array_search(trim(strtolower($val)), $acceptedValues) === false) {
                        return false;
                    }
                }

                return true;
            }
        );
        $resolver->setNormalizer(
            'type-blacklist',
            function (Options $options, $value) {

This code seems to be duplicated across your project.

                $valueArray = explode(',', $value);
                $formattedValueArray = array();
                foreach ($valueArray as $data) {
                    $formattedValueArray[] = trim(strtolower($data));
                }

                return implode(',', $formattedValueArray);
            }
        );
    }

    protected function setDependentOptions()
    {
        if ($this->options['output'] === self::OUTPUT_COMPACT) {
            $this->options['indent-spaces'] = 0;
        }
    }
}