NatePage\EasyHtmlElement\BranchValidator

Complexity

Total Complexity

13

Size/Duplication

Total Lines	104
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	validateBranch()	0	21	4
A	validateClass()	0	9	3
A	validateDefineHimself()	0	10	2
A	validateCircularReferences()	0	14	3

<?php

namespace NatePage\EasyHtmlElement;

use NatePage\EasyHtmlElement\Exception\InvalidElementException;

class BranchValidator implements BranchValidatorInterface
{
    /** @var HtmlElementInterface */
    private $htmlElement;

    /** @var array The options to check to valid a branch */
    private $checks = array('parent', 'extends', 'children');

    public function __construct(HtmlElementInterface $htmlElement)
    {
        $this->htmlElement = $htmlElement;
    }

    /**
     * Valid the current map branch.
     *
     * @param string $name     The current element name
     * @param array  $circular The array of elements names called in the current branch of map
     */
    public function validateBranch($name, array $circular = array())
    {
        $current = $this->htmlElement->getCurrentElement($name);

        $circular[] = $current['name'];

        $this->validateClass($current);

        foreach ($this->checks as $check) {
            if (isset($current[$check])) {
                $currentCheck = (array) $current[$check];

                $this->validateDefineHimself($current['name'], $currentCheck, $check);

                foreach ($currentCheck as $cc) {
                    $this->validateCircularReferences($current['name'], $cc, $check, $circular);
                    $this->validateBranch($cc, $circular);
                }
            }
        }
    }

    /**
     * Validate the current element class.
     *
     * @param array $current The current element
     *
     * @throws InvalidElementException If the current element defines a class which doesn't exist
     */
    private function validateClass(array $current)
    {
        if (isset($current['class']) && !class_exists($current['class'])) {
            throw new InvalidElementException(sprintf(
                'The element "%s" define a class which doesn\'t exist.',
                $current['name']
            ));
        }
    }

    /**
     * Validate himself references.
     *
     * @param string $name         The current element name
     * @param array  $currentCheck The current check context
     * @param string $check        The current check name
     *
     * @throws InvalidElementException If the current element defines himself as parent, children or extends
     */
    private function validateDefineHimself($name, array $currentCheck, $check)
    {
        if (in_array($name, $currentCheck)) {
            throw new InvalidElementException(sprintf(
                'Element "%s" cannot define himself as %s.',
                $name,
                $check
            ));
        }
    }

    /**
     * Validate circular references.
     *
     * @param string       $name         The current element name
     * @param string|array $currentCheck The current check context
     * @param string       $check        The current check name
     * @param array        $circular     The names of the previous elements called
     *
     * @throws InvalidElementException If the current element defines a parent, child or extends which creates circular
     *                                 reference
     */
    private function validateCircularReferences($name, $currentCheck, $check, array $circular)
    {
        if (!is_array($currentCheck) && in_array($currentCheck, $circular)) {
            $circular[] = $currentCheck;

            throw new InvalidElementException(sprintf(
                'Element "%s" cannot define "%s" as %s. It\'s a circular reference. [%s]',
                $name,
                $currentCheck,
                $check,
                implode(' -> ', $circular)
            ));
        }
    }
}