Query: parse as AST

src/Query/Query.php

@@ -3,6 +3,7 @@
 namespace Kirby\Query;
 
 use Closure;
+use Exception;
 use Kirby\Cms\App;
 use Kirby\Cms\Collection;
 use Kirby\Cms\File;
@@ -11,6 +12,8 @@
 use Kirby\Cms\User;
 use Kirby\Image\QrCode;
 use Kirby\Toolkit\I18n;
+use Kirby\Toolkit\Query\Runners\Interpreted;
+use Kirby\Toolkit\Query\Runners\Transpiled;
 
 /**
  * The Query class can be used to query arrays and objects,
@@ -38,6 +41,8 @@ class Query
 	 */
 	public static array $entries = [];
 
+	private static array $resolverCache = [];
+
 	/**
 	 * Creates a new Query object
 	 */
@@ -66,18 +71,8 @@ public function intercept(mixed $result): mixed
 		return $result;
 	}
 
-	/**
-	 * Returns the query result if anything
-	 * can be found, otherwise returns null
-	 *
-	 * @throws \Kirby\Exception\BadMethodCallException If an invalid method is accessed by the query
-	 */
-	public function resolve(array|object $data = []): mixed
+	private function resolve_legacy(array|object $data = []): mixed
 	{
-		if (empty($this->query) === true) {
-			return $data;
-		}
-
 		// merge data with default entries
 		if (is_array($data) === true) {
 			$data = [...static::$entries, ...$data];
@@ -99,6 +94,35 @@ public function resolve(array|object $data = []): mixed
 
 		// loop through all segments to resolve query
 		return Expression::factory($this->query, $this)->resolve($data);
+
+	}
+
+	/**
+	 * Returns the query result if anything
+	 * can be found, otherwise returns null
+	 *
+	 * @throws \Kirby\Exception\BadMethodCallException If an invalid method is accessed by the query
+	 */
+	public function resolve(array|object $data = []): mixed
+	{
+		if (empty($this->query) === true) {
+			return $data;
+		}
+
+		$mode = App::instance()->option('query.runner', 'interpreted');
+
+		if ($mode === 'legacy') {
+			return $this->resolve_legacy($data);
+		}
+
+		$runnerClass = match($mode) {
+			'transpiled' => Transpiled::class,
+			'interpreted' => Interpreted::class,
+			default => throw new Exception('Invalid query runner')
+		};
+
+		$runner = new $runnerClass(static::$entries, $this->intercept(...), static::$resolverCache);
+		return $runner->run($this->query, (array)$data);
 	}
 }
 

src/Toolkit/Query/AST/ArgumentListNode.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Kirby\Toolkit\Query\AST;
+
+class ArgumentListNode extends Node
+{
+	public function __construct(
+		public array $arguments,
+	) {
+	}
+}

src/Toolkit/Query/AST/ArrayListNode.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Kirby\Toolkit\Query\AST;
+
+class ArrayListNode extends Node
+{
+	public function __construct(
+		public array $elements,
+	) {
+	}
+}

src/Toolkit/Query/AST/ClosureNode.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Kirby\Toolkit\Query\AST;
+
+class ClosureNode extends Node
+{
+	/**
+	 * @param string[] $arguments The arguments names
+	 */
+	public function __construct(
+		public array $arguments,
+		public Node $body,
+	) {
+	}
+}

src/Toolkit/Query/AST/CoalesceNode.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Kirby\Toolkit\Query\AST;
+
+class CoalesceNode extends Node
+{
+	public function __construct(
+		public Node $left,
+		public Node $right,
+	) {
+	}
+}

src/Toolkit/Query/AST/GlobalFunctionNode.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Kirby\Toolkit\Query\AST;
+
+class GlobalFunctionNode extends IdentifierNode
+{
+	public function __construct(
+		public string $name,
+		public ArgumentListNode $arguments,
+	) {
+	}
+
+	/**
+	 * Replace escaped dots with real dots
+	 */
+	public function name(): string
+	{
+		return str_replace('\.', '.', $this->name);
+	}
+}

src/Toolkit/Query/AST/IdentifierNode.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Kirby\Toolkit\Query\AST;
+
+abstract class IdentifierNode extends Node
+{
+	/**
+	 * Replaces the escaped identifier with the actual identifier
+	 */
+	public static function unescape(string $name): string
+	{
+		return stripslashes($name);
+	}
+}

src/Toolkit/Query/AST/LiteralNode.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Kirby\Toolkit\Query\AST;
+
+class LiteralNode extends Node
+{
+	public function __construct(
+		public mixed $value,
+	) {
+	}
+}

src/Toolkit/Query/AST/MemberAccessNode.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Kirby\Toolkit\Query\AST;
+
+class MemberAccessNode extends IdentifierNode
+{
+	public function __construct(
+		public Node $object,
+		public string|int $member,
+		public ArgumentListNode|null $arguments = null,
+		public bool $nullSafe = false,
+	) {
+	}
+
+	/**
+	 * Returns the member name and replaces escaped dots with real dots if it's a string
+	 */
+	public function member(): string|int
+	{
+		if (is_string($this->member)) {
+			return self::unescape($this->member);
+		}
+		return $this->member;
+
+	}
+}

src/Toolkit/Query/AST/Node.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Kirby\Toolkit\Query\AST;
+
+use Kirby\Toolkit\Query\Visitor;
+
+class Node
+{
+	public function accept(Visitor $visitor)
+	{
+		return $visitor->visitNode($this);
+	}
+}

src/Toolkit/Query/AST/TernaryNode.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Kirby\Toolkit\Query\AST;
+
+class TernaryNode extends Node
+{
+	public function __construct(
+		public Node $condition,
+		public Node|null $trueBranch,
+		public Node $falseBranch,
+		public bool $trueBranchIsDefault = false,
+	) {
+	}
+}

src/Toolkit/Query/AST/VariableNode.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Kirby\Toolkit\Query\AST;
+
+class VariableNode extends IdentifierNode
+{
+	public function __construct(
+		public string $name,
+	) {
+	}
+
+	/**
+	 * Replaces escaped dots with real dots
+	 */
+	public function name(): string
+	{
+		return self::unescape($this->name);
+	}
+}

src/Toolkit/Query/BaseParser.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace Kirby\Toolkit\Query;
+
+use Exception;
+use Iterator;
+
+abstract class BaseParser
+{
+	protected Token|null $previous;
+	protected Token $current;
+
+	/**
+	 * @var Iterator<Token>
+	 */
+	protected Iterator $tokens;
+
+
+	public function __construct(
+		Tokenizer|Iterator $source,
+	) {
+		if ($source instanceof Tokenizer) {
+			$source = $source->tokenize();
+		}
+
+		$this->tokens = $source;
+		$first        = $this->tokens->current();
+
+		if ($first === null) {
+			throw new Exception('No tokens found.');
+		}
+
+		$this->current = $first;
+	}
+
+	protected function consume(TokenType $type, string $message): Token
+	{
+		if ($this->check($type) === true) {
+			return $this->advance();
+		}
+
+		throw new Exception($message);
+	}
+
+	protected function check(TokenType $type): bool
+	{
+		if ($this->isAtEnd() === true) {
+			return false;
+		}
+
+		return $this->current->type === $type;
+	}
+
+	protected function advance(): Token|null
+	{
+		if ($this->isAtEnd() === false) {
+			$this->previous = $this->current;
+			$this->tokens->next();
+			$this->current = $this->tokens->current();
+		}
+
+		return $this->previous;
+	}
+
+	protected function isAtEnd(): bool
+	{
+		return $this->current->type === TokenType::T_EOF;
+	}
+
+
+	protected function match(TokenType $type): Token|false
+	{
+		if ($this->check($type) === true) {
+			return $this->advance();
+		}
+
+		return false;
+	}
+
+	protected function matchAny(array $types): Token|false
+	{
+		foreach ($types as $type) {
+			if ($this->check($type) === true) {
+				return $this->advance();
+			}
+		}
+
+		return false;
+	}
+}