WIP

app/Support/Search/GdbotsQueryParser.php

@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FireflyIII\Support\Search;
+
+use FireflyIII\Exceptions\FireflyException;
+use Gdbots\QueryParser\QueryParser as BaseQueryParser;
+use Gdbots\QueryParser\Node as GdbotsNode;
+use Gdbots\QueryParser\Enum\BoolOperator;
+
+class GdbotsQueryParser implements QueryParserInterface
+{
+    private BaseQueryParser $parser;
+
+    public function __construct()
+    {
+        $this->parser = new BaseQueryParser();
+    }
+
+    /**
+     * @return Node[]
+     * @throws FireflyException
+     */
+    public function parse(string $query): array
+    {
+        try {
+            $result = $this->parser->parse($query);
+            return array_map(
+                fn(GdbotsNode\Node $node) => $this->convertNode($node),
+                $result->getNodes()
+            );
+        } catch (\LogicException|\TypeError $e) {
+            fwrite(STDERR, "Setting up GdbotsQueryParserTest\n");
+            dd('Creating GdbotsQueryParser');
+            app('log')->error($e->getMessage());
+            app('log')->error(sprintf('Could not parse search: "%s".', $query));
+
+            throw new FireflyException(sprintf('Invalid search value "%s". See the logs.', e($query)), 0, $e);
+        }
+    }
+
+    private function convertNode(GdbotsNode\Node $node): Node
+    {
+        switch (true) {
+            case $node instanceof GdbotsNode\Word:
+                return new Word($node->getValue());
+
+            case $node instanceof GdbotsNode\Field:
+                return new Field(
+                    $node->getValue(),
+                    (string) $node->getNode()->getValue(),
+                    BoolOperator::PROHIBITED === $node->getBoolOperator()
+                );
+
+            case $node instanceof GdbotsNode\Subquery:
+                return new Subquery(
+                    array_map(
+                        fn(GdbotsNode\Node $subNode) => $this->convertNode($subNode),
+                        $node->getNodes()
+                    )
+                );
+
+            case $node instanceof GdbotsNode\Phrase:
+            case $node instanceof GdbotsNode\Numbr:
+            case $node instanceof GdbotsNode\Date:
+            case $node instanceof GdbotsNode\Url:
+            case $node instanceof GdbotsNode\Hashtag:
+            case $node instanceof GdbotsNode\Mention:
+            case $node instanceof GdbotsNode\Emoticon:
+            case $node instanceof GdbotsNode\Emoji:
+                return new Word((string) $node->getValue());
+
+            default:
+                throw new FireflyException(
+                    sprintf('Unsupported node type: %s', get_class($node))
+                );
+        }
+    }
+}

app/Support/Search/OperatorQuerySearch.php

@@ -41,20 +41,6 @@ use FireflyIII\Repositories\Tag\TagRepositoryInterface;
 use FireflyIII\Repositories\UserGroups\Currency\CurrencyRepositoryInterface;
 use FireflyIII\Support\ParseDateString;
 use FireflyIII\User;
-use Gdbots\QueryParser\Enum\BoolOperator;
-use Gdbots\QueryParser\Node\Date;
-use Gdbots\QueryParser\Node\Emoji;
-use Gdbots\QueryParser\Node\Emoticon;
-use Gdbots\QueryParser\Node\Field;
-use Gdbots\QueryParser\Node\Hashtag;
-use Gdbots\QueryParser\Node\Mention;
-use Gdbots\QueryParser\Node\Node;
-use Gdbots\QueryParser\Node\Numbr;
-use Gdbots\QueryParser\Node\Phrase;
-use Gdbots\QueryParser\Node\Subquery;
-use Gdbots\QueryParser\Node\Url;
-use Gdbots\QueryParser\Node\Word;
-use Gdbots\QueryParser\QueryParser;
 use Illuminate\Pagination\LengthAwarePaginator;
 use Illuminate\Support\Collection;
 
@@ -145,10 +131,11 @@ class OperatorQuerySearch implements SearchInterface
     public function parseQuery(string $query): void
     {
         app('log')->debug(sprintf('Now in parseQuery(%s)', $query));
-        $parser = new QueryParser();
+        $parser = app(QueryParserInterface::class);
+        app('log')->debug(sprintf('Using %s as implementation for QueryParserInterface', get_class($parser)));
 
         try {
-            $query1 = $parser->parse($query);
+            $nodes = $parser->parse($query);
         } catch (\LogicException|\TypeError $e) {
             app('log')->error($e->getMessage());
             app('log')->error(sprintf('Could not parse search: "%s".', $query));
@@ -156,9 +143,9 @@ class OperatorQuerySearch implements SearchInterface
             throw new FireflyException(sprintf('Invalid search value "%s". See the logs.', e($query)), 0, $e);
         }
 
-        app('log')->debug(sprintf('Found %d node(s)', count($query1->getNodes())));
-        foreach ($query1->getNodes() as $searchNode) {
-            $this->handleSearchNode($searchNode);
+        app('log')->debug(sprintf('Found %d node(s)', count($nodes)));
+        foreach ($nodes as $node) {
+            $this->handleSearchNode($node);
         }
 
         // add missing information
@@ -173,81 +160,71 @@ class OperatorQuerySearch implements SearchInterface
      *
      * @SuppressWarnings(PHPMD.CyclomaticComplexity)
      */
-    private function handleSearchNode(Node $searchNode): void
+    private function handleSearchNode(Node $node): void
     {
-        $class = get_class($searchNode);
-        app('log')->debug(sprintf('Now in handleSearchNode(%s)', $class));
+        app('log')->debug(sprintf('Now in handleSearchNode(%s)', get_class($node)));
 
-        switch ($class) {
-            default:
-                app('log')->error(sprintf('Cannot handle node %s', $class));
-
-                throw new FireflyException(sprintf('Firefly III search can\'t handle "%s"-nodes', $class));
-
-            case Subquery::class:
-                // loop all notes in subquery:
-                foreach ($searchNode->getNodes() as $subNode) { // @phpstan-ignore-line PHPStan thinks getNodes() does not exist but it does.
-                    $this->handleSearchNode($subNode);          // let's hope it's not too recursive
-                }
-
-                break;
-
-            case Word::class:
-            case Phrase::class:
-            case Numbr::class:
-            case Url::class:
-            case Date::class:
-            case Hashtag::class:
-            case Emoticon::class:
-            case Emoji::class:
-            case Mention::class:
-                $allWords      = (string) $searchNode->getValue();
-                app('log')->debug(sprintf('Add words "%s" to search string, because Node class is "%s"', $allWords, $class));
+        switch (true) {
+            case $node instanceof Word:
+                $allWords      = (string) $node->getValue();
+                app('log')->debug(sprintf('Add words "%s" to search string', $allWords));
                 $this->words[] = $allWords;
-
                 break;
 
-            case Field::class:
-                app('log')->debug(sprintf('Now handle Node class %s', $class));
+            case $node instanceof Field:
+                $this->handleFieldNode($node);
+                break;
 
-                /** @var Field $searchNode */
-                // used to search for x:y
-                $operator      = strtolower($searchNode->getValue());
-                $value         = $searchNode->getNode()->getValue();
-                $prohibited    = BoolOperator::PROHIBITED === $searchNode->getBoolOperator();
-                $context       = config(sprintf('search.operators.%s.needs_context', $operator));
+            case $node instanceof Subquery:
+                foreach ($node->getNodes() as $subNode) {
+                    $this->handleSearchNode($subNode);
+                }
+                break;
 
-                // is an operator that needs no context, and value is false, then prohibited = true.
-                if ('false' === $value && in_array($operator, $this->validOperators, true) && false === $context && !$prohibited) {
-                    $prohibited = true;
-                    $value      = 'true';
-                }
-                // if the operator is prohibited, but the value is false, do an uno reverse
-                if ('false' === $value && $prohibited && in_array($operator, $this->validOperators, true) && false === $context) {
-                    $prohibited = false;
-                    $value      = 'true';
-                }
+            default:
+                app('log')->error(sprintf('Cannot handle node %s', get_class($node)));
+                throw new FireflyException(sprintf('Firefly III search can\'t handle "%s"-nodes', get_class($node)));
+        }
+    }
 
-                // must be valid operator:
-                if (
-                    in_array($operator, $this->validOperators, true)
-                    && $this->updateCollector($operator, (string) $value, $prohibited)) {
-                    $this->operators->push(
-                        [
-                            'type'       => self::getRootOperator($operator),
-                            'value'      => (string) $value,
-                            'prohibited' => $prohibited,
-                        ]
-                    );
-                    app('log')->debug(sprintf('Added operator type "%s"', $operator));
-                }
-                if (!in_array($operator, $this->validOperators, true)) {
-                    app('log')->debug(sprintf('Added INVALID operator type "%s"', $operator));
-                    $this->invalidOperators[] = [
-                        'type'  => $operator,
-                        'value' => (string) $value,
-                    ];
-                }
+    /**
+     * @throws FireflyException
+     */
+    private function handleFieldNode(Field $node): void
+    {
+        $operator = strtolower($node->getOperator());
+        $value = $node->getValue();
+        $prohibited = $node->isProhibited();
+
+        $context = config(sprintf('search.operators.%s.needs_context', $operator));
+
+        // is an operator that needs no context, and value is false, then prohibited = true.
+        if ('false' === $value && in_array($operator, $this->validOperators, true) && false === $context && !$prohibited) {
+            $prohibited = true;
+            $value = 'true';
+        }
+        // if the operator is prohibited, but the value is false, do an uno reverse
+        if ('false' === $value && $prohibited && in_array($operator, $this->validOperators, true) && false === $context) {
+            $prohibited = false;
+            $value = 'true';
+        }
+
+        // must be valid operator:
+        if (in_array($operator, $this->validOperators, true)) {
+            if ($this->updateCollector($operator, (string)$value, $prohibited)) {
+                $this->operators->push([
+                    'type' => self::getRootOperator($operator),
+                    'value' => (string)$value,
+                    'prohibited' => $prohibited,
+                ]);
+                app('log')->debug(sprintf('Added operator type "%s"', $operator));
+            }
+        } else {
+            app('log')->debug(sprintf('Added INVALID operator type "%s"', $operator));
+            $this->invalidOperators[] = [
+                'type' => $operator,
+                'value' => (string)$value,
+            ];
         }
     }
 

app/Support/Search/QueryParser.php

@@ -0,0 +1,171 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FireflyIII\Support\Search;
+
+/**
+ * Query parser class
+ */
+class QueryParser implements QueryParserInterface
+{
+    private string $query;
+    private int $position = 0;
+
+    /**
+     * @return Node[]
+     */
+    public function parse(string $query): array
+    {
+        $this->query = $query;
+        $this->position = 0;
+        return $this->parseQuery();
+    }
+
+    private function parseQuery(): array
+    {
+        $nodes = [];
+
+        while ($this->position < strlen($this->query)) {
+            $this->skipWhitespace();
+
+            if ($this->position >= strlen($this->query)) {
+                break;
+            }
+
+            // Handle subquery
+            if ($this->query[$this->position] === '(') {
+                $nodes[] = $this->parseSubquery();
+                continue;
+            }
+
+            // Handle field operator
+            if ($this->isStartOfField()) {
+                $nodes[] = $this->parseField();
+                continue;
+            }
+
+            // Handle word
+            $nodes[] = $this->parseWord();
+        }
+
+        return $nodes;
+    }
+
+    private function parseSubquery(): Subquery
+    {
+        $this->position++; // Skip opening parenthesis
+        $nodes = [];
+
+        while ($this->position < strlen($this->query)) {
+            $this->skipWhitespace();
+
+            if ($this->query[$this->position] === ')') {
+                $this->position++; // Skip closing parenthesis
+                break;
+            }
+
+            if ($this->query[$this->position] === '(') {
+                $nodes[] = $this->parseSubquery();
+                continue;
+            }
+
+            if ($this->isStartOfField()) {
+                $nodes[] = $this->parseField();
+                continue;
+            }
+
+            $nodes[] = $this->parseWord();
+        }
+
+        return new Subquery($nodes);
+    }
+
+    private function parseField(): Field
+    {
+        $prohibited = false;
+        if ($this->query[$this->position] === '-') {
+            $prohibited = true;
+            $this->position++;
+        }
+
+        $operator = '';
+        while ($this->position < strlen($this->query) && $this->query[$this->position] !== ':') {
+            $operator .= $this->query[$this->position];
+            $this->position++;
+        }
+        $this->position++; // Skip colon
+
+        $value = '';
+        $inQuotes = false;
+        while ($this->position < strlen($this->query)) {
+            $char = $this->query[$this->position];
+
+            if ($char === '"' && !$inQuotes) {
+                $inQuotes = true;
+                $this->position++;
+                continue;
+            }
+
+            if ($char === '"' && $inQuotes) {
+                $inQuotes = false;
+                $this->position++;
+                break;
+            }
+
+            if (!$inQuotes && ($char === ' ' || $char === ')')) {
+                break;
+            }
+
+            $value .= $char;
+            $this->position++;
+        }
+
+        return new Field(trim($operator), trim($value), $prohibited);
+    }
+
+    private function parseWord(): Word
+    {
+        $word = '';
+        while ($this->position < strlen($this->query)) {
+            $char = $this->query[$this->position];
+            if ($char === ' ' || $char === '(' || $char === ')') {
+                break;
+            }
+            $word .= $char;
+            $this->position++;
+        }
+        return new Word(trim($word));
+    }
+
+    private function isStartOfField(): bool
+    {
+        $pos = $this->position;
+        if ($this->query[$pos] === '-') {
+            $pos++;
+        }
+
+        // Look ahead for a colon that's not inside quotes
+        $inQuotes = false;
+        while ($pos < strlen($this->query)) {
+            if ($this->query[$pos] === '"') {
+                $inQuotes = !$inQuotes;
+            }
+            if ($this->query[$pos] === ':' && !$inQuotes) {
+                return true;
+            }
+            if ($this->query[$pos] === ' ' && !$inQuotes) {
+                return false;
+            }
+            $pos++;
+        }
+        return false;
+    }
+
+    private function skipWhitespace(): void
+    {
+        while ($this->position < strlen($this->query) && $this->query[$this->position] === ' ') {
+            $this->position++;
+        }
+    }
+}

app/Support/Search/QueryParserInterface.php

@@ -0,0 +1,112 @@
+<?php
+
+declare(strict_types=1);
+
+namespace FireflyIII\Support\Search;
+
+interface QueryParserInterface
+{
+    /**
+     * @return Node[]
+     */
+    public function parse(string $query): array;
+}
+
+
+/**
+ * Base class for all nodes
+ */
+abstract class Node
+{
+    abstract public function __toString(): string;
+}
+
+/**
+ * Represents a word in the search query
+ */
+class Word extends Node
+{
+    private string $value;
+
+    public function __construct(string $value)
+    {
+        $this->value = $value;
+    }
+
+    public function getValue(): string
+    {
+        return $this->value;
+    }
+
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+}
+
+/**
+ * Represents a field operator with value (e.g. amount:100)
+ */
+class Field extends Node
+{
+    private string $operator;
+    private string $value;
+    private bool $prohibited;
+
+    public function __construct(string $operator, string $value, bool $prohibited = false)
+    {
+        $this->operator = $operator;
+        $this->value = $value;
+        $this->prohibited = $prohibited;
+    }
+
+    public function getOperator(): string
+    {
+        return $this->operator;
+    }
+
+    public function getValue(): string
+    {
+        return $this->value;
+    }
+
+    public function isProhibited(): bool
+    {
+        return $this->prohibited;
+    }
+
+    public function __toString(): string
+    {
+        return ($this->prohibited ? '-' : '') . $this->operator . ':' . $this->value;
+    }
+}
+
+/**
+ * Represents a subquery (group of nodes)
+ */
+class Subquery extends Node
+{
+    /** @var Node[] */
+    private array $nodes;
+
+    /**
+     * @param Node[] $nodes
+     */
+    public function __construct(array $nodes)
+    {
+        $this->nodes = $nodes;
+    }
+
+    /**
+     * @return Node[]
+     */
+    public function getNodes(): array
+    {
+        return $this->nodes;
+    }
+
+    public function __toString(): string
+    {
+        return '(' . implode(' ', array_map(fn($node) => (string)$node, $this->nodes)) . ')';
+    }
+}