Refactor grammar into static filter factory

Author: stevebauman

src/Query/Builder.php

@@ -16,6 +16,7 @@
 use LdapRecord\Query\Events\QueryExecuted;
 use LdapRecord\Query\Filter\AndGroup;
 use LdapRecord\Query\Filter\Filter;
+use LdapRecord\Query\Filter\Factory;
 use LdapRecord\Query\Filter\Not;
 use LdapRecord\Query\Filter\OrGroup;
 use LdapRecord\Query\Filter\Raw;
@@ -120,8 +121,7 @@ class Builder
      * Constructor.
      */
     public function __construct(
-        protected Connection $connection,
-        protected Grammar $grammar = new Grammar,
+        protected Connection $connection
     ) {}
 
     /**
@@ -134,16 +134,6 @@ public function setConnection(Connection $connection): static
         return $this;
     }
 
-    /**
-     * Set the current filter grammar.
-     */
-    public function setGrammar(Grammar $grammar): static
-    {
-        $this->grammar = $grammar;
-
-        return $this;
-    }
-
     /**
      * Set the cache to store query results.
      */
@@ -219,7 +209,7 @@ public function getQuery(): string
             $this->whereHas('objectclass');
         }
 
-        return $this->grammar->compile($this);
+        return (string) $this->filter;
     }
 
     /**
@@ -238,14 +228,6 @@ public function getUnescapedQuery(): string
         return EscapedValue::unescape($this->getQuery());
     }
 
-    /**
-     * Get the current grammar instance.
-     */
-    public function getGrammar(): Grammar
-    {
-        return $this->grammar;
-    }
-
     /**
      * Get the current cache instance.
      */
@@ -834,15 +816,15 @@ public function where(Closure|array|string $attribute, mixed $operator = null, m
             $value, $operator, func_num_args() === 2 && ! $this->operatorRequiresValue($operator)
         );
 
-        if (! in_array($operator, $this->grammar->operators())) {
+        if (! in_array($operator, Factory::operators())) {
             throw new InvalidArgumentException("Invalid LDAP filter operator [$operator]");
         }
 
         $value = $this->prepareWhereValue($attribute, $value, $raw);
 
         $attribute = $this->escape($attribute)->forDnAndFilter()->get();
 
-        $filter = $this->grammar->makeFilter($operator, $attribute, $value);
+        $filter = Factory::make($operator, $attribute, $value);
 
         $this->addFilter($filter, $boolean);
 

src/Query/Filter/Factory.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace LdapRecord\Query\Filter;
+
+use UnexpectedValueException;
+
+class Factory
+{
+    /**
+     * The query operators and their filter classes.
+     */
+    protected static array $operators = [
+        '*' => Has::class,
+        '!*' => [Not::class, Has::class],
+        '=' => Equals::class,
+        '!' => [Not::class, Equals::class],
+        '!=' => [Not::class, Equals::class],
+        '>=' => GreaterThanOrEquals::class,
+        '<=' => LessThanOrEquals::class,
+        '~=' => ApproximatelyEquals::class,
+        'starts_with' => StartsWith::class,
+        'not_starts_with' => [Not::class, StartsWith::class],
+        'ends_with' => EndsWith::class,
+        'not_ends_with' => [Not::class, EndsWith::class],
+        'contains' => Contains::class,
+        'not_contains' => [Not::class, Contains::class],
+    ];
+
+    /**
+     * Get the available operators.
+     */
+    public static function operators(): array
+    {
+        return array_keys(static::$operators);
+    }
+
+    /**
+     * Make a filter instance for the operator.
+     *
+     * @throws UnexpectedValueException
+     */
+    public static function make(string $operator, string $attribute, ?string $value = null): Filter
+    {
+        if (! array_key_exists($operator, static::$operators)) {
+            throw new UnexpectedValueException("Invalid LDAP filter operator ['$operator']");
+        }
+
+        $classes = static::$operators[$operator];
+
+        // Handle negated operators (Ex: [Not::class, Equals::class])
+        if (is_array($classes)) {
+            [$wrapper, $filter] = $classes;
+
+            return new $wrapper(static::create($filter, $attribute, $value));
+        }
+
+        return static::create($classes, $attribute, $value);
+    }
+
+    /**
+     * Create a filter instance.
+     */
+    protected static function create(string $filter, string $attribute, ?string $value = null): Filter
+    {
+        return $filter === Has::class
+            ? new $filter($attribute)
+            : new $filter($attribute, $value);
+    }
+}

src/Query/Grammar.php

@@ -67,7 +67,6 @@ class Builder
         'getconnection',
         'getdn',
         'getfilters',
-        'getgrammar',
         'getselects',
         'gettype',
         'getunescapedquery',

src/Query/Model/Builder.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace LdapRecord\Tests\Unit\Query\Filter;
+
+use LdapRecord\Query\Filter\Equals;
+use LdapRecord\Query\Filter\Factory;
+use LdapRecord\Query\Filter\Has;
+use LdapRecord\Query\Filter\Not;
+use LdapRecord\Tests\TestCase;
+use UnexpectedValueException;
+
+class FactoryTest extends TestCase
+{
+    public function test_all_operators()
+    {
+        $expected = [
+            '*', '!*', '=', '!', '!=', '>=', '<=',
+            '~=', 'starts_with', 'not_starts_with',
+            'ends_with', 'not_ends_with', 'contains', 'not_contains',
+        ];
+
+        $this->assertEquals($expected, Factory::operators());
+    }
+
+    public function test_make_filter()
+    {
+        $filter = Factory::make('=', 'cn', 'John Doe');
+
+        $this->assertInstanceOf(Equals::class, $filter);
+        $this->assertEquals('cn', $filter->getAttribute());
+        $this->assertEquals('=', $filter->getOperator());
+        $this->assertEquals('John Doe', $filter->getValue());
+    }
+
+    public function test_make_filter_with_negated_operator()
+    {
+        $filter = Factory::make('!=', 'cn', 'John Doe');
+
+        $this->assertInstanceOf(Not::class, $filter);
+        $this->assertInstanceOf(Equals::class, $filter->getFilter());
+    }
+
+    public function test_make_filter_with_has_operator()
+    {
+        $filter = Factory::make('*', 'cn');
+
+        $this->assertInstanceOf(Has::class, $filter);
+    }
+
+    public function test_make_filter_with_not_has_operator()
+    {
+        $filter = Factory::make('!*', 'cn');
+
+        $this->assertInstanceOf(Not::class, $filter);
+        $this->assertInstanceOf(Has::class, $filter->getFilter());
+    }
+
+    public function test_make_filter_with_invalid_operator()
+    {
+        $this->expectException(UnexpectedValueException::class);
+
+        Factory::make('foo', 'cn');
+    }
+}