Kadet\Highlighter\Parser\Token\Token

Complexity

Total Complexity

45

Size/Duplication

Total Lines	225
Duplicated Lines	8.89 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

97.2%

Importance

Changes	4
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
D	__construct()	0	31	8
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()	10	10	2
A	getEnd()	0	4	1
A	setEnd()	10	10	2
A	getLength()	0	8	3
A	__get()	0	4	1
B	process()	0	30	6
B	compare()	0	20	11

<?php
/**
 * Highlighter
 *
 * Copyright (C) 2016, Some right reserved.
 *
 * @author Kacper "Kadet" Donat <kacper@kadet.net>
 *
 * Contact with author:
 * Xmpp: me@kadet.net
 * E-mail: contact@kadet.net
 *
 * From Kadet with love.
 */

namespace Kadet\Highlighter\Parser\Token;

use Kadet\Highlighter\Language\Language;
use Kadet\Highlighter\Parser\Result;
use Kadet\Highlighter\Parser\Rule;
use Kadet\Highlighter\Parser\TokenIterator;
use Kadet\Highlighter\Parser\Validator\Validator;
use Kadet\Highlighter\Utils\ArrayHelper;
use Kadet\Highlighter\Utils\Helper;

class Token
{
    const NAME  = null;
    const START = 0x1;
    const END   = 0x2;

    protected static $_id = 0;

    public $pos;
    public $name;
    public $closedBy;
    public $index = 1;
    public $id;
    public $rule;

    # region >>> cache
    /**
     * @var static|null|false
     */
    protected $_end;

    /**
     * @var static|null|false
     */
    protected $_start;

    protected $_valid;
    protected $_length;
    # endregion

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

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

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

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

        $this->rule = isset($options['rule']) ? $options['rule'] : new Rule();

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

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

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

    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->validator->validate($context, $this->isEnd() ? [$this->name => Validator::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 Token|null|false
     */
    public function getStart()
    {
        return $this->_start;
    }

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

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

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

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

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

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

        return $this->_length;
    }

    public function __get($name)
    {
        return $this->rule->$name;
    }

    /**
     * @param array         $context
     * @param Language      $language
     * @param Result        $result
     * @param TokenIterator $tokens
     *
     * todo: Documentation
     *
     * @return bool Continue?
     */
    public function process(array &$context, Language $language, Result $result, TokenIterator $tokens) {
        if(!$this->isValid($language, $context)) {
            return true;
        }

        if($this->isStart()) {
            $result->append($this);
            $context[$tokens->key()] = $this->name;
        } else {
            if($this->_start) {
                unset($context[spl_object_hash($this->_start)]);
            } else {
                $start = ArrayHelper::find(array_reverse($context), function ($k, $v) {
                    return $v === $this->closedBy;
                });

                if ($start !== false) {
                    $this->setStart($tokens[$start]);

                    unset($context[$start]);
                }
            }

            if (!$this->_start instanceof MetaToken) {
                $result->append($this);
            }
        }

        return true;
    }

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

        if (($a->isStart() && $b->isEnd()) || ($a->isEnd() && $b->isStart())) {
            if ($a->getStart() == $b) {
                return 1;
            } elseif ($a->getEnd() == $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);
        }
    }
}