Kadet\Highlighter\Parser\Token

Complexity

Total Complexity

43

Size/Duplication

Total Lines	211
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

98.85%

Importance

Changes	23
Bugs	3	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
C	__construct()	0	30	7
B	compare()	0	20	11
A	isStart()	0	4	1
A	isEnd()	0	4	1
A	isValid()	0	8	2
A	validate()	0	7	3
A	setValid()	0	10	3
A	getStart()	0	4	1
A	setStart()	0	9	2
A	getEnd()	0	4	1
A	setEnd()	0	10	2
A	getRule()	0	4	1
A	setRule()	0	4	1
A	getLength()	0	8	3
A	dump()	0	16	4

<?php
/**
 * Highlighter
 *
 * Copyright (C) 2015, Some right reserved.
 *
 * @author Kacper "Kadet" Donat <kadet1090@gmail.com>
 *
 * Contact with author:
 * Xmpp: kadet@jid.pl
 * E-mail: kadet1090@gmail.com
 *
 * From Kadet with love.
 */

namespace Kadet\Highlighter\Parser;


use Kadet\Highlighter\Language\Language;
use Kadet\Highlighter\Utils\Helper;
use Kadet\Highlighter\Utils\StringHelper;

class Token
{
    const NAME = null;

    protected static $_id = 0;

    public $pos;
    public $name;
    public $index = 1;

    /**
     * @var Token
     */
    protected $_end;

    /**
     * @var Token
     */
    protected $_start;

    /** @var Rule */
    protected $_rule;

    protected $_valid;
    protected $_length;

    public $id;

    /**
     * Token constructor.
     *
     * @param array $options
     */
    public function __construct(array $options)
    {
        if (isset($options[0])) {
            $this->name = $options[0];
        }

        if (isset($options['pos'])) {
            $this->pos = $options['pos'];
        }

        if (isset($options['index'])) {
            $this->index = $options['index'];
        }

        if (isset($options['start'])) {
            $this->setStart($options['start']);
        }

        if (isset($options['rule'])) {
            $this->setRule($options['rule']);
        } else {
            $this->setRule(new Rule());
        }

        if (isset($options['end'])) {
            $this->setEnd($options['end']);
        }

        $this->id = ++self::$_id;
    }

    public static function compare(Token $a, Token $b)
    {
        $multiplier = $a->isEnd() ? -1 : 1;

        if (($a->isStart() && $b->isEnd()) || ($a->isEnd() && $b->isStart())) {
            if($a->getEnd() == $b) {
                return -1;
            } elseif($a->getStart() == $b) {
                return 1;
            } else {
                return $multiplier;
            }
        } elseif (($rule = Helper::cmp($b->_rule->priority, $a->_rule->priority)) !== 0) {
            return $multiplier*$rule;
        } elseif (($rule = Helper::cmp($b->index, $a->index)) !== 0) {
            return $multiplier*$rule;
        } else {
            return $multiplier*($a->id < $b->id ? -1 : 1);
        }
    }

    public function isStart()
    {
        return $this->_start === null;
    }

    public function isEnd()
    {
        return $this->_end === null;
    }

    public function isValid(Language $language, $context = null)
    {
        if ($this->_valid === null) {
            $this->validate($language, $context);
        }

        return $this->_valid;
    }

    protected function validate(Language $language, $context)
    {
        $this->setValid(
            $language === $this->_rule->language &&
            $this->_rule->validateContext($context, $this->isEnd() ? [$this->name => Rule::CONTEXT_IN] : [])
        );
    }

    public function setValid($valid = true)
    {
        $this->_valid = $valid;

        if ($this->_end) {
            $this->_end->_valid = $this->_valid;
        } elseif ($this->_start) {
            $this->_start->_valid = $this->_valid;
        }
    }

    /**
     * @return mixed
     */
    public function getStart()
    {
        return $this->_start;
    }

    /**
     * @param Token|null|false $start
     */
    public function setStart($start = null)
    {
        $this->_end = null;
        $this->_start = $start;

It seems like $start can also be of type false. However, the property $_start is declared as type object<Kadet\Highlighter\Parser\Token>. Maybe add an additional type check?

        if ($start instanceof Token) {
            $start->_end = $this;
        }
    }

    /**
     * @return Token|null
     */
    public function getEnd()
    {
        return $this->_end;
    }

    /**
     * @param Token|null|false $end
     */
    public function setEnd($end = null)
    {
        $this->_start = null;
        $this->_end = $end;

It seems like $end can also be of type false. However, the property $_end is declared as type object<Kadet\Highlighter\Parser\Token>. Maybe add an additional type check?

        $this->_length = null;

        if ($end instanceof Token) {
            $end->_start = $this;
        }
    }

    /**
     * @return Rule
     */
    public function getRule()
    {
        return $this->_rule;
    }

    /**
     * @param Rule $rule
     */
    public function setRule(Rule $rule)
    {
        $this->_rule = $rule;
    }

    public function getLength()
    {
        if ($this->_length === null) {
            $this->_length = $this->_end === null ? 0 : $this->_end->pos - $this->pos;
        }

        return $this->_length;
    }

    /**
     * @codeCoverageIgnore
     */
    public function dump($text = null)
    {
        $pos = StringHelper::positionToLine($text, $this->pos);
        $pos = $pos['line'] . ':' . $pos['pos'];

        if ($this->isStart()) {
            $result = "Start ({$this->name}) $pos";
            if ($text !== null && $this->_end !== null) {
                $result .= "  \x02" . substr($text, $this->pos, $this->_end->pos - $this->pos) . "\x03";
            }
        } else {
            $result = "End ({$this->name}) $pos";
        }

        return $result;
    }
}