Kevintweber\HtmlTokenizer\Tokens\AbstractToken

Complexity

Total Complexity

24

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	18	3
A	getDepth()	0	4	1
A	getLine()	0	4	1
A	isClosingElementImplied()	0	4	1
A	getParent()	0	4	1
A	getPosition()	0	4	1
A	getThrowOnError()	0	4	1
A	getType()	0	4	1
A	getValue()	0	4	1
A	isCDATA()	0	4	1
A	isComment()	0	4	1
A	isDocType()	0	4	1
A	isElement()	0	4	1
A	isPhp()	0	4	1
A	isText()	0	4	1
B	isValidType()	0	9	6
A	setTokenPosition()	0	6	1

<?php

namespace Kevintweber\HtmlTokenizer\Tokens;

use Kevintweber\HtmlTokenizer\HtmlTokenizer;

abstract class AbstractToken implements Token
{
    /** @var int */
    private $depth;

    /** @var int */
    protected $line;

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

    /** @var int */
    protected $position;

    /** @var boolean */
    private $throwOnError;

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

    /** @var string */
    protected $value;

    /**
     * Constructor
     *
     * @param string     $type
     * @param Token|null $parent
     * @param bool       $throwOnError
     *
     * @throws \InvalidArgumentException
     */
    public function __construct(string $type, Token $parent = null, bool $throwOnError = false)
    {
        if (!$this->isValidType($type)) {
            throw new \InvalidArgumentException('Invalid type: ' . $type);
        }

        $this->depth = 0;
        if ($parent instanceof Token) {
            $this->depth = $parent->getDepth() + 1;
        }

        $this->line = 0;
        $this->position = 0;
        $this->parent = $parent;
        $this->throwOnError = $throwOnError;
        $this->type = $type;
        $this->value = '';
    }

    public function getDepth() : int
    {
        return $this->depth;
    }

    /**
     * Getter for 'line'.
     */
    public function getLine() : int
    {
        return $this->line;
    }

    public function isClosingElementImplied(string $html) : bool
    {
        return false;
    }

    public function getParent()
    {
        return $this->parent;
    }

    /**
     * Getter for 'position'.
     */
    public function getPosition() : int
    {
        return $this->position;
    }

    /**
     * Getter for 'throwOnError'.
     *
     * @return boolean
     */
    protected function getThrowOnError() : bool
    {
        return $this->throwOnError;
    }

    /**
     * Getter for 'type'.
     *
     * @return string
     */
    public function getType() : string
    {
        return $this->type;
    }

    /**
     * Getter for "value"
     *
     * @return string
     */
    public function getValue() : string
    {
        return $this->value;
    }

    public function isCDATA() : bool
    {
        return $this->type === Token::CDATA;
    }

    public function isComment() : bool
    {
        return $this->type === Token::COMMENT;
    }

    public function isDocType() : bool
    {
        return $this->type === Token::DOCTYPE;
    }

    public function isElement() : bool
    {
        return $this->type === Token::ELEMENT;
    }

    public function isPhp() : bool
    {
        return $this->type === Token::PHP;
    }

    public function isText() : bool
    {
        return $this->type === Token::TEXT;
    }

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

    protected function setTokenPosition(string $html)
    {
        $positionArray = HtmlTokenizer::getPosition($html);
        $this->line = $positionArray['line'];
        $this->position = $positionArray['position'];
    }
}