Groundskeeper\Tokens\AbstractToken

Complexity

Total Complexity

22

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

95.83%

Importance

Changes	6
Bugs	0	Features	4

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	getDepth()	0	4	1
A	getParent()	0	4	1
A	setParent()	0	11	2
A	getType()	0	4	1
B	isValidType()	0	8	5
D	cleanChildTokens()	0	31	10

<?php

namespace Groundskeeper\Tokens;

use Groundskeeper\Configuration;
use Groundskeeper\Exceptions\ValidationException;
use Groundskeeper\Tokens\Elements\Elements;
use Psr\Log\LoggerInterface;

abstract class AbstractToken implements Token
{
    /** @var Configuration */
    protected $configuration;

    /** @var int */
    private $depth;

    /** @var null|Token */
    private $parent;

    /** @var string */
    private $type;

    /**
     * Constructor
     */
    public function __construct($type, Configuration $configuration, Token $parent = null)
    {
        if (!$this->isValidType($type)) {
            throw new \InvalidArgumentException('Invalid type: ' . $type);
        }

        $this->configuration = $configuration;
        $this->setParent($parent);
        $this->type = $type;
    }

    /**
     * Required by the Token interface.
     */
    public function getDepth()
    {
        return $this->depth;
    }

    /**
     * Required by the Token interface.
     */
    public function getParent()
    {
        return $this->parent;
    }

    /**
     * Chainable setter for 'parent'.
     */
    public function setParent(Token $parent = null)
    {
        $this->depth = 0;
        if ($parent instanceof Token) {
            $this->depth = $parent->getDepth() + 1;
        }

        $this->parent = $parent;

        return $this;
    }

    /**
     * Required by the Token interface.
     */
    public function getType()
    {
        return $this->type;
    }

    protected function isValidType($type)
    {
        return $type === Token::CDATA
            || $type === Token::COMMENT
            || $type === Token::DOCTYPE
            || $type === Token::ELEMENT
            || $type === Token::TEXT;
    }

    public static function cleanChildTokens(Configuration $configuration, array &$children, LoggerInterface $logger = null)
    {
        if ($configuration->get('clean-strategy') == Configuration::CLEAN_STRATEGY_NONE) {
            return true;
        }

        foreach ($children as $key => $child) {
            if ($child instanceof Cleanable) {
                $isClean = $child->clean($logger);
                if (!$isClean) {
                    $message = 'invalid token. Unable to fix: ' . $child->getType();

It seems like you code against a concrete implementation and not the interface Groundskeeper\Tokens\Cleanable as the method getType() does only exist in the following implementations of said interface: Groundskeeper\Tokens\DocType, Groundskeeper\Tokens\Elements\Base, Groundskeeper\Tokens\Elements\Body, Groundskeeper\Tokens\Elements\Br, Groundskeeper\Tokens\Elements\ClosedElement, Groundskeeper\Tokens\Elements\Element, Groundskeeper\Tokens\Elements\Head, Groundskeeper\Tokens\Elements\Hr, Groundskeeper\Tokens\Elements\Html, Groundskeeper\Tokens\Elements\Link, Groundskeeper\Tokens\Elements\Meta, Groundskeeper\Tokens\Elements\OpenElement, Groundskeeper\Tokens\Elements\Style.

                    if ($child instanceof Element) {

The class Groundskeeper\Tokens\Element does not exist. Did you forget a USE statement, or did you not list all dependencies?

                        $message = 'invalid element. Unable to fix: ' . $child->getName();
                    }

                    if ($configuration->get('error-strategy') == Configuration::ERROR_STRATEGY_THROW) {
                        throw new ValidationException(ucfirst($message));
                    }

                    if ($configuration->get('error-strategy') == Configuration::ERROR_STRATEGY_FIX || $configuration->get('error-strategy') == Configuration::ERROR_STRATEGY_REMOVE) {
                        unset($children[$key]);
                        if ($logger !== null) {
                            $logger->debug('Removing ' . $message);
                        }
                    }
                }
            }
        }

        return true;
    }
}