Kevintweber\HtmlTokenizer\Tokens\AbstractToken

Complexity

Total Complexity

17

Size/Duplication

Total Lines	96
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

51.61%

Importance

Changes	3
Bugs	0	Features	1

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	getThrowOnError()	0	4	1
A	getType()	0	4	1
A	isAttribute()	0	4	1
A	isCDATA()	0	4	1
A	isComment()	0	4	1
A	isDocType()	0	4	1
A	isElement()	0	4	1
A	isText()	0	4	1
B	isValidType()	0	9	6
A	getParent()	0	4	1

<?php

namespace Kevintweber\HtmlTokenizer\Tokens;

abstract class AbstractToken implements Token
{
    /** @var null|Token */
    private $parent;

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

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

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

        $this->parent = $parent;
        $this->throwOnError = (boolean) $throwOnError;
        $this->type = $type;
    }

    /**
     * Getter for 'parent'.
     *
     * @return Token
     */
    public function getParent()
    {
        return $this->parent;
    }

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

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


    public function isAttribute()
    {
        return $this->type === Token::ATTRIBUTE;
    }

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

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

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

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

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

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