Replace Filter::equal and Filter::unequal with Filter::similar and Filter::unlike correspondingly

Author: raviks789

src/Control/SearchBar/ValidatedOperator.php

@@ -21,9 +21,11 @@ class ValidatedOperator extends ValidatedTerm
     public static function fromFilterCondition(Filter\Condition $condition)
     {
         switch (true) {
+            case $condition instanceof Filter\Unlike:
             case $condition instanceof Filter\Unequal:
                 $operator = '!=';
                 break;
+            case $condition instanceof Filter\Similar:
             case $condition instanceof Filter\Equal:
                 $operator = '=';
                 break;

src/Control/SearchEditor.php

@@ -173,19 +173,38 @@ protected function applyChanges(Filter\Rule $rule, array &$values, array $path =
 
             $newOperator = $this->popKey($values, $identifier . '-operator');
             if ($newOperator !== null && QueryString::getRuleSymbol($rule) !== $newOperator) {
+                $value = $rule->getValue();
+                $column = $rule->getColumn();
                 switch ($newOperator) {
                     case '=':
-                        return Filter::equal($rule->getColumn(), $rule->getValue());
+                        if (is_string($value) && strpos($value, '*') !== false) {
+                            return Filter::similar($column, $value);
+                        }
+
+                        return Filter::equal($column, $value);
                     case '!=':
-                        return Filter::unequal($rule->getColumn(), $rule->getValue());
+                        if (is_string($value) && strpos($value, '*') !== false) {
+                            return Filter::unlike($column, $value);
+                        }
+
+                        return Filter::unequal($column, $value);
                     case '>':
-                        return Filter::greaterThan($rule->getColumn(), $rule->getValue());
+                        return Filter::greaterThan($column, $value);
                     case '>=':
-                        return Filter::greaterThanOrEqual($rule->getColumn(), $rule->getValue());
+                        return Filter::greaterThanOrEqual($column, $value);
                     case '<':
-                        return Filter::lessThan($rule->getColumn(), $rule->getValue());
+                        return Filter::lessThan($column, $value);
                     case '<=':
-                        return Filter::lessThanOrEqual($rule->getColumn(), $rule->getValue());
+                        return Filter::lessThanOrEqual($column, $value);
+                }
+            }
+
+            $value = $rule->getValue();
+            if (is_string($value) && strpos($value, '*') !== false) {
+                if (QueryString::getRuleSymbol($rule) === '=') {
+                    return Filter::similar($rule->getColumn(), $value);
+                } elseif (QueryString::getRuleSymbol($rule) === '!=') {
+                    return Filter::unlike($rule->getColumn(), $value);
                 }
             }
         } else {

src/Filter/Parser.php

@@ -516,8 +516,16 @@ protected function createCondition($column, $operator, $value)
 
         switch ($operator) {
             case '=':
+                if (is_string($value) && strpos($value, "*") !== false) {
+                    return Filter::similar($column, $value);
+                }
+
                 return Filter::equal($column, $value);
             case '!=':
+                if (is_string($value) && strpos($value, '*') !== false) {
+                    return Filter::unlike($column, $value);
+                }
+
                 return Filter::unequal($column, $value);
             case '>':
                 return Filter::greaterThan($column, $value);

src/Filter/QueryString.php

@@ -67,8 +67,10 @@ public static function getRuleSymbol(Filter\Rule $rule)
     {
         switch (true) {
             case $rule instanceof Filter\Unequal:
+            case $rule instanceof Filter\Unlike:
                 return '!=';
             case $rule instanceof Filter\Equal:
+            case $rule instanceof Filter\Similar:
                 return '=';
             case $rule instanceof Filter\GreaterThan:
                 return '>';

src/Filter/Renderer.php

@@ -152,9 +152,11 @@ protected function renderCondition(Filter\Condition $condition)
 
         switch (true) {
             case $condition instanceof Filter\Unequal:
+            case $condition instanceof Filter\Unlike:
                 $this->string .= '!=';
                 break;
             case $condition instanceof Filter\Equal:
+            case $condition instanceof Filter\Similar:
                 $this->string .= '=';
                 break;
             case $condition instanceof Filter\GreaterThan:

tests/FilterTest.php

@@ -23,6 +23,25 @@ public function testParserIdentifiesSingleConditions()
         );
     }
 
+    public function testParserIdentifiesWildCardCharacters()
+    {
+        $expectedSimilar = QueryString::render(Filter::similar('foo', 'ba*'));
+
+        $this->assertEquals(
+            $expectedSimilar,
+            QueryString::render(QueryString::parse($expectedSimilar)),
+            "Filter\Parser doesn't parse conditions with wildcard character correctly"
+        );
+
+        $expectedUnlike = QueryString::render(Filter::unlike('foo', 'ba*'));
+
+        $this->assertEquals(
+            $expectedUnlike,
+            QueryString::render(QueryString::parse($expectedUnlike)),
+            "Filter\Parser doesn't parse conditions with wildcard character correctly"
+        );
+    }
+
     public function testParserIdentifiesBooleanConditions()
     {
         $expectedTrue = QueryString::render(Filter::equal('active', true));
@@ -56,13 +75,27 @@ public function testParserIdentifiesRelationalOperators()
             "Filter\Parser doesn't parse = comparisons correctly"
         );
 
+        $expectedSimilar = QueryString::render(Filter::similar('foo', 'ba*'));
+        $this->assertEquals(
+            $expectedSimilar,
+            QueryString::render(QueryString::parse($expectedSimilar)),
+            "Filter\Parser doesn't parse != comparisons correctly for wildcard characters"
+        );
+
         $expectedUnequal = QueryString::render(Filter::unequal('foo', 'bar'));
         $this->assertEquals(
             $expectedUnequal,
             QueryString::render(QueryString::parse($expectedUnequal)),
             "Filter\Parser doesn't parse != comparisons correctly"
         );
 
+        $expectedUnlike = QueryString::render(Filter::unlike('foo', 'ba*'));
+        $this->assertEquals(
+            $expectedUnlike,
+            QueryString::render(QueryString::parse($expectedUnlike)),
+            "Filter\Parser doesn't parse != comparisons correctly for wildcard characters"
+        );
+
         $expectedGreaterThan = QueryString::render(Filter::greaterThan('length', 3));
         $this->assertEquals(
             $expectedGreaterThan,
@@ -340,6 +373,9 @@ public function testParserIdentifiesTheHolyGrail()
             /* testParserIdentifiesBooleanConditions */
             Filter::equal('active', true),
             Filter::equal('active', false),
+            /* testParserIdentifiesWildCardCharacters */
+            Filter::similar('foo', 'ba*'),
+            Filter::unlike('foo', 'ba*'),
             /* testParserIdentifiesRelationalOperators */
             Filter::unequal('foo', 'bar'),
             Filter::greaterThan('length', 3),