Kolyunya\Codeception\Module\MarkupValidator

Complexity

Total Complexity

15

Size/Duplication

Total Lines	223
Duplicated Lines	13.45 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	8
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	initializeMarkupProvider()	0	10	1
A	initializeMarkupValidator()	0	7	1
A	initializeMessageFilter()	0	7	1
A	initializeMessagePrinter()	0	7	1
A	instantiateComponent()	0	17	2
A	getComponentConfiguration()	16	16	3
A	validateMarkup()	0	16	2
A	getComponentClass()	14	14	3

<?php

namespace Kolyunya\Codeception\Module;

use Exception;
use ReflectionClass;
use Codeception\Lib\ModuleContainer;
use Codeception\Module;
use Kolyunya\Codeception\Lib\Base\ComponentInterface;
use Kolyunya\Codeception\Lib\MarkupValidator\MarkupProviderInterface;
use Kolyunya\Codeception\Lib\MarkupValidator\MarkupValidatorInterface;
use Kolyunya\Codeception\Lib\MarkupValidator\MessageFilterInterface;
use Kolyunya\Codeception\Lib\MarkupValidator\MessagePrinterInterface;

/**
 * A module which validates page markup via a markup validator.
 */
class MarkupValidator extends Module
{

    const COMPONENT_CLASS_CONFIG_KEY = 'class';

    const COMPONENT_CONFIG_CONFIG_KEY = 'config';

    const PROVIDER_INTERFACE = 'Kolyunya\Codeception\Lib\MarkupValidator\MarkupProviderInterface';
    const PROVIDER_CONFIG_KEY = 'provider';

    const VALIDATOR_INTERFACE = 'Kolyunya\Codeception\Lib\MarkupValidator\MarkupValidatorInterface';
    const VALIDATOR_CONFIG_KEY = 'validator';

    const FILTER_INTERFACE = 'Kolyunya\Codeception\Lib\MarkupValidator\MessageFilterInterface';
    const FILTER_CONFIG_KEY = 'filter';

    const PRINTER_INTERFACE = 'Kolyunya\Codeception\Lib\MarkupValidator\MessagePrinterInterface';
    const PRINTER_CONFIG_KEY = 'printer';

    /**
     * {@inheritDoc}
     */
    protected $config = array(
        self::PROVIDER_CONFIG_KEY => array(
            self::COMPONENT_CLASS_CONFIG_KEY => 'Kolyunya\Codeception\Lib\MarkupValidator\DefaultMarkupProvider',
        ),
        self::VALIDATOR_CONFIG_KEY => array(
            self::COMPONENT_CLASS_CONFIG_KEY => 'Kolyunya\Codeception\Lib\MarkupValidator\W3CMarkupValidator',
        ),
        self::FILTER_CONFIG_KEY => array(
            self::COMPONENT_CLASS_CONFIG_KEY => 'Kolyunya\Codeception\Lib\MarkupValidator\DefaultMessageFilter',
        ),
        self::PRINTER_CONFIG_KEY => array(
            self::COMPONENT_CLASS_CONFIG_KEY => 'Kolyunya\Codeception\Lib\MarkupValidator\DefaultMessagePrinter',
        ),
    );

    /**
     * Markup provider.
     *
     * @var MarkupProviderInterface
     */
    private $markupProvider;

    /**
     * Markup validator.
     *
     * @var MarkupValidatorInterface
     */
    private $markupValidator;

    /**
     * Message filter.
     *
     * @var MessageFilterInterface
     */
    private $messageFilter;

    /**
     * Message printer.
     *
     * @var MessagePrinterInterface
     */
    private $messagePrinter;

    /**
     * {@inheritDoc}
     */
    public function __construct(ModuleContainer $moduleContainer, $config = null)
    {
        parent::__construct($moduleContainer, $config);

        $this->initializeMarkupProvider();
        $this->initializeMarkupValidator();
        $this->initializeMessageFilter();
        $this->initializeMessagePrinter();
    }

    /**
     * Validates page markup via a markup validator.
     * Allows to recongigure message filter component.
     *
     * @param array $messageFilterConfiguration Message filter configuration.
     */
    public function validateMarkup(array $messageFilterConfiguration = array())
    {
        $markup = $this->markupProvider->getMarkup();
        $messages = $this->markupValidator->validate($markup);

        $this->messageFilter->setConfiguration($messageFilterConfiguration);
        $filteredMessages = $this->messageFilter->filterMessages($messages);

        if (empty($filteredMessages) === false) {
            $messagesString = $this->messagePrinter->getMessagesString($filteredMessages);
            $this->fail($messagesString);
        }

        // Validation succeeded.
        $this->assertTrue(true);
    }

    /**
     * Initializes markup provider.
     */
    private function initializeMarkupProvider()
    {
        $this->markupProvider = $this->instantiateComponent(
            self::PROVIDER_CONFIG_KEY,
            self::PROVIDER_INTERFACE,
            array(
                $this->moduleContainer,
            )
        );
    }

    /**
     * Initializes markup validator.
     */
    private function initializeMarkupValidator()
    {
        $this->markupValidator = $this->instantiateComponent(
            self::VALIDATOR_CONFIG_KEY,
            self::VALIDATOR_INTERFACE
        );
    }

    /**
     * Initializes message filter.
     */
    private function initializeMessageFilter()
    {
        $this->messageFilter = $this->instantiateComponent(
            self::FILTER_CONFIG_KEY,
            self::FILTER_INTERFACE
        );
    }

    /**
     * Initializes message printer.
     */
    private function initializeMessagePrinter()
    {
        $this->messagePrinter = $this->instantiateComponent(

It seems like $this->instantiateComponent(self::PRINTER_CONFIG_KEY, self::PRINTER_INTERFACE) of type object<Kolyunya\Codeception\Lib\Base\ComponentInterface> is incompatible with the declared type object<Kolyunya\Codeception\Lib\MarkupValidator\MessagePrinterInterface> of property $messagePrinter.

            self::PRINTER_CONFIG_KEY,
            self::PRINTER_INTERFACE
        );
    }

    /**
     * Instantiates and returns a module component.
     *
     * @param string $componentName Component name.
     * @param string $interface An interface component must implement.
     * @param array $arguments Component's constructor arguments.
     *
     * @throws Exception When component does not implement expected interface.
     *
     * @return ComponentInterface Instance of a module component.
     */
    private function instantiateComponent($componentName, $interface, array $arguments = array())
    {
        $componentClass = $this->getComponentClass($componentName);
        $componentReflectionClass = new ReflectionClass($componentClass);
        if ($componentReflectionClass->implementsInterface($interface) === false) {
            $errorMessageTemplate = 'Invalid class «%s» provided for component «%s». It must implement «%s».';
            $errorMessage = sprintf($errorMessageTemplate, $componentClass, $componentName, $interface);
            throw new Exception($errorMessage);
        }

        /* @var $component ComponentInterface */
        $component = $componentReflectionClass->newInstanceArgs($arguments);
        $componentConfiguration = $this->getComponentConfiguration($componentName);
        $component->setConfiguration($componentConfiguration);

        return $component;
    }

    /**
     * Returns component class name.
     *
     * @param string $componentName Component name.
     *
     * @return string Component class name.
     */
    private function getComponentClass($componentName)

This method seems to be duplicated in your project.

    {
        $componentClassKey = self::COMPONENT_CLASS_CONFIG_KEY;
        if (isset($this->config[$componentName][$componentClassKey]) === false ||
            is_string($this->config[$componentName][$componentClassKey]) === false
        ) {
            $errorMessage = sprintf('Invalid class configuration of component «%s».', $componentName);
            throw new Exception($errorMessage);
        }

        $componentClass = $this->config[$componentName][$componentClassKey];

        return $componentClass;
    }

    /**
     * Returns component configuration parameters.
     *
     * @param string $componentName Component name.
     *
     * @return array Component configuration parameters.
     */
    private function getComponentConfiguration($componentName)

This method seems to be duplicated in your project.

    {
        $componentConfig = array();

        $componentConfigKey = self::COMPONENT_CONFIG_CONFIG_KEY;
        if (isset($this->config[$componentName][$componentConfigKey]) === true) {
            if (is_array($this->config[$componentName][$componentConfigKey]) === true) {
                $componentConfig = $this->config[$componentName][$componentConfigKey];
            } else {
                $errorMessage = sprintf('Invalid configuration of component «%s».', $componentName);
                throw new Exception($errorMessage);
            }
        }

        return $componentConfig;
    }
}