php-kilo/src/Row.php

<?php declare(strict_types=1);

namespace Aviat\Kilo;

use Aviat\Kilo\Enum\Highlight;
use Aviat\Kilo\Enum\RawKeyCode;

/**
 * @property-read int $size
 * @property-read int $rsize
 * @property-read string $chars
 */
class Row {
	/**
	 * The version of the row to be displayed (where tabs are converted to display spaces)
	 */
	public string $render = '';

	/**
	 * The mapping of characters to their highlighting type
	 */
	public array $hl = [];

	/**
	 * Are we in the middle of highlighting a multi-line comment?
	 */
	private bool $hlOpenComment = FALSE;

	/**
	 * Create a row in the current document
	 *
	 * @param Document $parent
	 * @param string $chars
	 * @param int $idx
	 * @return self
	 */
	public static function new(Document $parent, string $chars, int $idx): self
	{
		return new self(
			$parent,
			$chars,
			$idx,
		);
	}

	/**
	 * Create an empty Row
	 *
	 * @return self
	 */
	public static function default(): self
	{
		return new self(
			Document::new(),
			'',
			0,
		);
	}

	private function __construct(
		/**
		 * The document that this row belongs to
		 */
		private Document $parent,

		/**
		 * @var string The raw characters in the row
		 */
		private string $chars,

		/**
		 * @var int The line number of the current row
		 */
		public int $idx,
	) {}

	public function __get(string $name): mixed
	{
		return match ($name)
		{
			'size' => strlen($this->chars),
			'rsize' => strlen($this->render),
			'chars' => $this->chars,
			default => NULL,
		};
	}

	/**
	 * Convert the row contents to a string for saving
	 *
	 * @return string
	 */
	public function __toString(): string
	{
		return $this->chars . "\n";
	}

	/**
	 * Set the properties to display for var_dump
	 *
	 * @return array
	 */
	public function __debugInfo(): array
	{
		return [
			'size' => $this->size,
			'rsize' => $this->rsize,
			'chars' => $this->chars,
			'render' => $this->render,
			'hl' => $this->hl,
			'hlOpenComment' => $this->hlOpenComment,
		];
	}

	/**
	 * Is this row a valid part of a document?
	 *
	 * @return bool
	 */
	public function isValid(): bool
	{
		return ! $this->parent->isEmpty();
	}

	/**
	 * Insert the string or character $c at index $at
	 *
	 * @param int $at
	 * @param string $c
	 */
	public function insert(int $at, string $c): void
	{
		if ($at < 0 || $at > $this->size)
		{
			$this->append($c);
			return;
		}

		// Safely insert into arbitrary position in the existing string
		$this->chars = substr($this->chars, 0, $at) . $c . substr($this->chars, $at);
		$this->update();
	}

	/**
	 * Append $s to the current row
	 *
	 * @param string $s
	 */
	public function append(string $s): void
	{
		$this->chars .= $s;
		$this->update();
	}

	/**
	 * Delete the character at the specified index
	 *
	 * @param int $at
	 */
	public function delete(int $at): void
	{
		if ($at < 0 || $at >= $this->size)
		{
			return;
		}

		$this->chars = substr_replace($this->chars, '', $at, 1);
		$this->update();
	}

	/**
	 * Set the contents of the Row
	 *
	 * @param string $chars
	 */
	public function setChars(string $chars): void
	{
		$this->chars = $chars;
		$this->update();
	}

	/**
	 * Convert tabs to spaces for display, and update syntax highlighting
	 */
	public function update(): void
	{
		$this->render = tabs_to_spaces($this->chars);
		$this->highlight();
	}

	// ------------------------------------------------------------------------
	// ! Syntax Highlighting
	// ------------------------------------------------------------------------

	/**
	 * Parse the current file to apply syntax highlighting
	 */
	public function highlight(): void
	{
		$this->hl = array_fill(0, $this->rsize, Highlight::NORMAL);

		if ($this->parent->fileType->name === 'PHP')
		{
			$this->highlightPHP();
			return;
		}

		if ($this->parent->fileType->name === 'No filetype')
		{
			return;
		}

		$syntax = $this->parent->fileType->syntax;

		$mcs = $syntax->multiLineCommentStart;
		$mce = $syntax->multiLineCommentEnd;

		$mcsLen = strlen($mcs);
		$mceLen = strlen($mce);

		$inString = '';
		$inComment = ($this->idx > 0 && $this->parent->rows[$this->idx - 1]->hlOpenComment);

		$i = 0;

		while ($i < $this->rsize)
		{
			// Multi-line comments
			if ($syntax->mlComments() && $inString === '')
			{
				if ($inComment)
				{
					$this->hl[$i] = Highlight::ML_COMMENT;
					if (substr($this->render, $i, $mceLen) === $mce)
					{
						array_replace_range($this->hl, $i, $mceLen, Highlight::ML_COMMENT);
						$i += $mceLen;
						$inComment = FALSE;
						continue;
					}

					$i++;
					continue;
				}

				if (substr($this->render, $i, $mcsLen) === $mcs)
				{
					array_replace_range($this->hl, $i, $mcsLen, Highlight::ML_COMMENT);
					$i += $mcsLen;
					$inComment = TRUE;
					continue;
				}
			}

			if (
				$this->highlightCharacter($i, $syntax)
				|| $this->highlightComment($i, $syntax)
				|| $this->highlightPrimaryKeywords($i, $syntax)
				|| $this->highlightSecondaryKeywords($i, $syntax)
				|| $this->highlightString($i, $syntax)
				|| $this->highlightOperators($i, $syntax)
				|| $this->highlightCommonDelimeters($i)
				|| $this->highlightCommonOperators($i, $syntax)
				|| $this->highlightNumber($i, $syntax)
			) {
				continue;
			}

			$i++;
		}

		$changed = $this->hlOpenComment !== $inComment;
		$this->hlOpenComment = $inComment;
		if ($changed && $this->idx + 1 < $this->parent->numRows)
		{
			$this->parent->rows[$this->idx + 1]->update();
		}
	}

	/**
	 * Highlight number literals
	 *
	 * @param int $i
	 * @param Syntax $opts
	 * @return bool
	 */
	protected function highlightNumber(int &$i, Syntax $opts): bool
	{
		$char = $this->render[$i];
		if ($opts->numbers() && is_digit($char) && $this->hl[$i] === Highlight::NORMAL)
		{
			if ($i > 0)
			{
				$prevChar = $this->render[$i - 1];
				if ( ! is_separator($prevChar))
				{
					return false;
				}
			}

			while (true)
			{
				$this->hl[$i] = Highlight::NUMBER;
				$i++;

				if ($i < strlen($this->render))
				{
					$nextChar = $this->render[$i];
					if (stripos('abcdefx.1234567890', $nextChar) === FALSE)
					{
						return true;
					}

					continue;
				}

				break;
			}
		}

		return false;
	}

	/**
	 * Highlight keywords and/or operators
	 *
	 * @param int $i
	 * @param array $keywords
	 * @param int $syntaxType
	 * @param bool $requireSeparator
	 * @return bool
	 */
	protected function highlightWord(int &$i, array $keywords, int $syntaxType, bool $requireSeparator = true): bool
	{
		if ($i > 0 && $requireSeparator)
		{
			$prevChar = $this->render[$i - 1];
			if ( ! is_separator($prevChar))
			{
				return false;
			}
		}

		foreach ($keywords as $k)
		{
			$klen = strlen($k);
			$nextCharOffset = $i + $klen;
			$isEndOfLine = $nextCharOffset >= $this->rsize;
			$nextChar = ($isEndOfLine) ? RawKeyCode::NULL : $this->render[$nextCharOffset];

			if (substr($this->render, $i, $klen) === $k && is_separator($nextChar))
			{
				array_replace_range($this->hl, $i, $klen, $syntaxType);
				$i += $klen;

				return true;
			}
		}

		return false;
	}

	/**
	 * Highlight a single-char character from a list of provided keywords
	 *
	 * @param int $i
	 * @param array $chars
	 * @param int $syntaxType
	 * @return bool
	 */
	protected function highlightChar(int &$i, array $chars, int $syntaxType): bool
	{
		if ($this->hl[$i] !== Highlight::NORMAL)
		{
			return false;
		}

		$char = $this->render[$i];

		if (in_array($char, $chars, TRUE))
		{
			$this->hl[$i] = $syntaxType;
			$i++;

			return true;
		}

		return false;
	}

	/**
	 * Highlight primary keywords
	 *
	 * @param int $i
	 * @param Syntax $opts
	 * @return bool
	 */
	protected function highlightPrimaryKeywords(int &$i, Syntax $opts): bool
	{
		return $this->highlightWord($i, $opts->keywords1, Highlight::KEYWORD1);
	}

	/**
	 * Highlight secondary keywords
	 *
	 * @param int $i
	 * @param Syntax $opts
	 * @return bool
	 */
	protected function highlightSecondaryKeywords(int &$i, Syntax $opts): bool
	{
		return $this->highlightWord($i, $opts->keywords2, Highlight::KEYWORD2);
	}

	/**
	 * Highlight language-specific operators
	 *
	 * @param int $i
	 * @param Syntax $opts
	 * @return bool
	 */
	protected function highlightOperators(int &$i, Syntax $opts): bool
	{
		return $this->highlightWord($i, $opts->operators, Highlight::OPERATOR, false);
	}

	/**
	 * Highlight common single-character operators
	 *
	 * @param int $i
	 * @param Syntax $opts
	 * @return bool
	 */
	protected function highlightCommonOperators(int &$i, Syntax $opts): bool
	{
		if ( ! $opts->commonOperators())
		{
			return false;
		}

		return $this->highlightChar(
			$i,
			['+', '-', '*', '/', '<', '^', '>', '%', '=', ':', ',', ';', '&', '~', '!', '|', '.'],
			Highlight::OPERATOR
		);
	}

	/**
	 * Highlight brackets and braces
	 *
	 * @param int $i
	 * @return bool
	 */
	protected function highlightCommonDelimeters(int &$i): bool
	{
		return $this->highlightChar(
			$i,
			['{', '}', '[', ']', '(', ')'],
			Highlight::DELIMITER
		);
	}

	/**
	 * Highlight character literals
	 *
	 * @param int $i
	 * @param Syntax $opts
	 * @return bool
	 */
	protected function highlightCharacter(int &$i, Syntax $opts): bool
	{
		$char = $this->render[$i];

		if (($i + 1) >= $this->rsize || $char !== "'")
		{
			return false;
		}
		$nextChar = $this->render[$i + 1];

		if ($opts->characters())
		{
			$offset = ($nextChar === '\\') ? $i + 3 : $i + 1;
			$closingIndex = strpos($this->render, "'", $offset);
			if ($closingIndex === false)
			{
				return false;
			}

			$closingChar = $this->render[$closingIndex];
			if ($closingChar === "'")
			{
				array_replace_range($this->hl, $i, $closingIndex - $i + 1, Highlight::CHARACTER);
				$i = $closingIndex + 1;

				return true;
			}
		}

		return false;
	}

	/**
	 * Highlight single-line comments
	 *
	 * @param int $i
	 * @param Syntax $opts
	 * @return bool
	 */
	protected function highlightComment(int &$i, Syntax $opts): bool
	{
		if ( ! $opts->comments())
		{
			return false;
		}

		$scs = $opts->singleLineCommentStart;
		$scsLen = strlen($scs);

		if ($scsLen > 0 && substr($this->render, $i, $scsLen) === $scs)
		{
			array_replace_range($this->hl, $i, $this->rsize - $i, Highlight::COMMENT);
			$i = $this->rsize;

			return true;
		}

		return false;
	}

	/**
	 * Highlight quote-delimited string literals
	 *
	 * @param int $i
	 * @param Syntax $opts
	 * @return bool
	 */
	protected function highlightString(int &$i, Syntax $opts): bool
	{
		$char = $this->render[$i];

		// If there's a separate character type, highlight that separately
		if ($opts->hasChar() && $char === "'")
		{
			return false;
		}

		if ($opts->strings() && ($char === '"' || $char === '\''))
		{
			$quote = $char;
			$this->hl[$i] = Highlight::STRING;
			$i++;

			while ($i < $this->rsize)
			{
				$char = $this->render[$i];
				$this->hl[$i] = Highlight::STRING;

				// Check for escaped character
				if ($char === '\\' && $i+1 < $this->rsize)
				{
					$this->hl[$i + 1] = Highlight::STRING;
					$i += 2;
					continue;
				}

				// End of the string!
				$i++;
				if ($char === $quote)
				{
					break;
				}
			}

			return true;
		}

		return false;
	}

	/**
	 * Highlight PHP code based on pre-parsed tokens
	 */
	protected function highlightPHP(): void
	{
		$rowNum = $this->idx + 1;

		$hasRowTokens = array_key_exists($rowNum, $this->parent->tokens);

		if ( ! (
			$hasRowTokens &&
			$this->idx < $this->parent->numRows
		))
		{
			return;
		}

		$tokens = $this->parent->tokens[$rowNum];

		$inComment = ($this->idx > 0 && $this->parent->rows[$this->idx - 1]->hlOpenComment);

		// Keep track of where you are in the line, so that
		// multiples of the same tokens can be effectively matched
		$offset = 0;

		foreach ($tokens as $token)
		{
			if ($offset >= $this->rsize)
			{
				break;
			}

			// A multi-line comment can end in the middle of a line...
			if ($inComment)
			{
				// Try looking for the end of the comment first
				$commentEnd = strpos($this->render, '*/');
				if ($commentEnd !== FALSE)
				{
					$inComment = FALSE;
					array_replace_range($this->hl, 0, $commentEnd + 2, Highlight::ML_COMMENT);
					$offset = $commentEnd;
					continue;
				}

				// Otherwise, just set the whole row
				$this->hl = array_fill(0, $this->rsize, Highlight::ML_COMMENT);
				$this->hl[$offset] = Highlight::ML_COMMENT;
				break;
			}

			$char = $token['char'];
			$charLen = strlen($char);
			if ($charLen === 0 || $offset >= $this->rsize)
			{
				continue;
			}
			$charStart = strpos($this->render, $char, $offset);
			if ($charStart === FALSE)
			{
				continue;
			}
			$charEnd = $charStart + $charLen;

			// Start of multiline comment/single line comment
			if (in_array($token['type'], [T_DOC_COMMENT, T_COMMENT], TRUE))
			{
				// Single line comments
				if (str_contains($char, '//') || str_contains($char, '#'))
				{
					array_replace_range($this->hl, $charStart, $charLen, Highlight::COMMENT);
					break;
				}

				// Start of multi-line comment
				$start = strpos($this->render, '/*', $offset);
				$end = strpos($this->render, '*/', $offset);
				$hasStart = $start !== FALSE;
				$hasEnd = $end !== FALSE;

				if ($hasStart)
				{
					if ($hasEnd)
					{
						$len = $end - $start + 2;
						array_replace_range($this->hl, $start, $len, Highlight::ML_COMMENT);
						$inComment = FALSE;
					}
					else
					{
						$inComment = TRUE;
						array_replace_range($this->hl, $start, $charLen - $offset, Highlight::ML_COMMENT);
						$offset = $start + $charLen - $offset;
					}
				}

				if ($inComment)
				{
					break;
				}
			}

			$tokenHighlight = Highlight::fromPHPToken($token['type']);
			$charHighlight = Highlight::fromPHPChar(trim($token['char']));

			$highlight = match(true) {
				// Matches a predefined PHP token
				$token['type'] !== T_RAW && $tokenHighlight !== Highlight::NORMAL
				=> $tokenHighlight,

				// Matches a specific syntax character
				$charHighlight !== Highlight::NORMAL => $charHighlight,

				default => Highlight::NORMAL,
			};

			if ($highlight !== Highlight::NORMAL)
			{
				array_replace_range($this->hl, $charStart, $charLen, $highlight);
				$offset = $charEnd;
			}
		}

		$changed = $this->hlOpenComment !== $inComment;
		$this->hlOpenComment = $inComment;
		if ($changed && ($this->idx + 1) < $this->parent->numRows)
		{
			$this->parent->rows[$this->idx + 1]->highlight();
		}
	}
}