php-kilo/src/Document.php

<?php declare(strict_types=1);

namespace Aviat\Kilo;

use Aviat\Kilo\Tokens\PHP8;
use Aviat\Kilo\Type\Point;

/**
 * The representation of the current document being edited
 *
 * @property-read int $numRows
 */
class Document {
	public FileType $fileType;

	// Tokens for highlighting PHP
	public array $tokens = [];

	private function __construct(
		public array $rows = [],
		public string $filename = '',
		public bool $dirty = FALSE,
	) {
		$this->fileType = FileType::from($this->filename);
	}

	public function __get(string $name): ?int
	{
		if ($name === 'numRows')
		{
			return count($this->rows);
		}

		return NULL;
	}

	public static function default(): self
	{
		return new self();
	}

	protected function rowsToString(): string
	{
		$lines = array_map(fn (Row $row) => (string)$row, $this->rows);

		return implode('', $lines);
	}

	public static function open(string $filename): ?self
	{
		$handle = fopen($filename, 'rb');
		if ($handle === FALSE)
		{
			return NULL;
		}

		$self = new self(filename: $filename);

		while (($line = fgets($handle)) !== FALSE)
		{
			// Remove line endings when reading the file
			$self->insertRow($self->numRows, rtrim($line), FALSE);
		}

		fclose($handle);

		$self->selectSyntaxHighlight();

		return $self;
	}

	public function save(): int|false
	{
		$contents = $this->rowsToString();

		$res = file_put_contents($this->filename, $contents);

		if ($res === strlen($contents))
		{
			$this->dirty = FALSE;
		}

		return $res;
	}

	public function insert(Point $at, string $c): void
	{
		if ($at->y === $this->numRows)
		{
			$this->insertRow($this->numRows, '');
		}
		$this->rows[$at->y]->insertChar($at->x, $c);
	}

	public function insertRow(int $at, string $s, bool $updateSyntax = TRUE): void
	{
		if ($at > $this->numRows)
		{
			return;
		}

		$row = Row::new($this, $s, $at);

		if ($at === $this->numRows)
		{
			$this->rows[] = $row;
		}
		else
		{
			$this->rows = [
				...array_slice($this->rows, 0, $at),
				$row,
				...array_slice($this->rows, $at),
			];

			// Update indexes of each row so that correct highlighting is done
			for ($idx = $at; $idx < $this->numRows; $idx++)
			{
				$this->rows[$idx]->idx = $idx;
			}
		}

		ksort($this->rows);

		$this->rows[$at]->update();

		$this->dirty = true;

		// Re-tokenize the file
		if ($updateSyntax)
		{
			$this->refreshPHPSyntax();
		}
	}

	public function isDirty(): bool
	{
		return $this->dirty;
	}

	public function deleteChar(Point $at): void
	{

	}

	protected function insertNewline(): void
	{
		// @TODO attempt smart indentation on newline?

		if ($this->cursor->x === 0)
		{
			$this->insertRow($this->cursor->y, '');
		}
		else
		{
			$row = $this->rows[$this->cursor->y];
			$chars = $row->chars;
			$newChars = substr($chars, 0, $this->cursor->x);

			// Truncate the previous row
			$row->chars = $newChars;

			// Add a new row, with the contents from the cursor to the end of the line
			$this->insertRow($this->cursor->y + 1, substr($chars, $this->cursor->x));
		}

		$this->cursor->y++;
		$this->cursor->x = 0;

		// Re-tokenize the file
		$this->refreshPHPSyntax();
	}

	public function selectSyntaxHighlight(): void
	{
		if (empty($this->filename))
		{
			return;
		}

		if ($this->fileType->name === 'PHP')
		{
			$this->tokens = PHP8::getFileTokens($this->filename);
		}

		$this->refreshSyntax();
	}

	public function refreshSyntax(): void
	{
		// Update the syntax highlighting for all the rows of the file
		array_walk($this->rows, static fn (Row $row) => $row->update());
	}

	private function refreshPHPSyntax(): void
	{
		if ($this->fileType->name !== 'PHP')
		{
			return;
		}

		$this->tokens = PHP8::getTokens($this->rowsToString());
		$this->refreshSyntax();
	}
}