Railt\Console\Highlighter

Complexity

Total Complexity

20

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	add()	0	4	1
A	highlight()	0	10	3
A	renderLanguage()	0	23	5
A	splitToken()	0	18	4
A	isRenderable()	0	6	2
A	renderErrorToken()	0	6	2
A	renderBasicToken()	0	6	2

<?php
/**
 * This file is part of Railt package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace Railt\Console;

use Railt\Console\Language\Generic;
use Railt\Console\Language\LanguageInterface;
use Railt\Io\Readable;
use Railt\Lexer\Result\Token;
use Railt\Lexer\TokenInterface;

/**
 * Class Highlighter
 */
class Highlighter
{
    /**
     * @var int
     */
    private const CODE_SECTION_SIZE = 5;

    /**
     * @var array|LanguageInterface[]
     */
    private $languages = [];

    /**
     * Highlighter constructor.
     * @throws \InvalidArgumentException
     * @throws \Railt\Lexer\Exception\BadLexemeException
     */
    public function __construct()
    {
        $this->add(new Generic());
    }

    /**
     * @param LanguageInterface $language
     */
    public function add(LanguageInterface $language): void
    {
        \array_unshift($this->languages, $language);
    }

    /**
     * @param Readable $file
     * @param int $line
     * @return string
     */
    public function highlight(Readable $file, int $line): string
    {
        foreach ($this->languages as $language) {
            if ($language->match($file)) {
                return $this->renderLanguage($language, $file, $line);
            }
        }

        return $file->getContents();
    }

    /**
     * @param LanguageInterface $language
     * @param Readable $file
     * @param int $errorLine
     * @return string
     */
    private function renderLanguage(LanguageInterface $language, Readable $file, int $errorLine): string
    {
        $result        = '';
        $lastLine      = 0;

        foreach ($language->lex($file) as $token) {
            foreach ($this->splitToken($token) as $child) {
                $current = $file->getPosition($child->getOffset())->getLine();

                if ($this->isRenderable($errorLine, $current)) {
                    $atStart = $lastLine !== $current;

                    $result .= $errorLine === $current
                        ? $this->renderErrorToken($child, $current, $atStart)
                        : $this->renderBasicToken($language, $child, $current, $atStart);
                }

                $lastLine = $current;
            }
        }

        return $result;
    }

    /**
     * @param TokenInterface $token
     * @return iterable|TokenInterface[]
     */
    private function splitToken(TokenInterface $token): iterable
    {
        $offset = $token->getOffset();
        $chunks = \explode("\n", $token->getValue());
        $size   = \count($chunks);

        foreach ($chunks as $i => $chunk) {
            $result = new Token($token->getName(), $chunk, $offset);

            yield $result;

            if ($size > 1 && $size > $i + 1) {
                yield new Token('T_WHITESPACE', "\n", $offset++);
            }

            $offset += $result->getBytes();
        }
    }

    /**
     * @param int $errorLine
     * @param int $current
     * @return bool
     */
    private function isRenderable(int $errorLine, int $current): bool
    {
        return
            $current >= $errorLine - self::CODE_SECTION_SIZE &&
            $current <= $errorLine + self::CODE_SECTION_SIZE;
    }

    /**
     * @param TokenInterface $token
     * @param int $line
     * @param bool $start
     * @return string
     */
    private function renderErrorToken(TokenInterface $token, int $line, bool $start): string
    {
        $prefix = $start ? \sprintf('<fg=red;bg=white;options=bold,blink>%4d |></>', $line) : '';

        return $prefix . '<fg=white;bg=red;options=bold>' . $token->getValue() . '</>';
    }

    /**
     * @param LanguageInterface $language
     * @param TokenInterface $token
     * @param int $line
     * @param bool $start
     * @return string
     */
    private function renderBasicToken(LanguageInterface $language, TokenInterface $token, int $line, bool $start): string
    {
        $prefix = $start ? \sprintf('<fg=blue>%4d | </>', $line) : '';

        return $prefix . $language->highlight($token->getName(), $token->getValue());
    }
}