Use PHP 8.1 features

.github/workflows/phpqa.yml

@@ -8,14 +8,14 @@ jobs:
     steps:
       - uses: actions/checkout@master
       - name: PHPStan
-        uses: docker://jakzal/phpqa:php8.0-alpine
+        uses: docker://jakzal/phpqa:php8.1
         with:
           args: phpstan analyze src/ -l 1
       - name: PHP-CS-Fixer
-        uses: docker://jakzal/phpqa:php8.0-alpine
+        uses: docker://jakzal/phpqa:php8.1
         with:
           args: php-cs-fixer --dry-run --allow-risky=yes --no-interaction --ansi fix
       - name: Deptrac
-        uses: docker://jakzal/phpqa:php8.0-alpine
+        uses: docker://jakzal/phpqa:php8.1
         with:
           args: deptrac --no-interaction --ansi --formatter-graphviz-display=0

.gitignore

@@ -3,3 +3,5 @@
 /coverage.clover
 /.phpunit.result.cache
 /vendor/
+/.idea
+/.composer

.scrutinizer.yml

@@ -35,8 +35,9 @@ tools:
     enabled: true
     excluded_dirs: [tests]
 build:
+  image: default-bionic
   environment:
-    php: 8.0.1
+    php: 8.1.0
   nodes:
     analysis:
       tests:

.styleci.yml

@@ -1,10 +1,12 @@
 ---
 preset: psr2
 risky: true
-version: 8
+version: 8.1
 finder:
   name:
     - "*.php"
 enabled:
   - short_array_syntax
   - cast_spaces
+disabled:
+  - lowercase_constants

.travis.yml

@@ -1,7 +1,7 @@
 language: php
 
 php:
-  - 8.0
+  - 8.1
 
 script:
   - composer install --dev

README.md

@@ -18,8 +18,6 @@ Find me on Twitter: @[nicoSWD](https://twitter.com/nicoSWD)
 
 (If you're using PHP 5, you might want to take a look at [version 0.4.0](https://github.com/nicoSWD/php-rule-parser/tree/0.4.0))
 
-[![SensioLabsInsight](https://insight.sensiolabs.com/projects/67203389-970c-419c-9430-a7f9a005bd94/big.png)](https://insight.sensiolabs.com/projects/67203389-970c-419c-9430-a7f9a005bd94)
-
 ## Install
 
 Via Composer
@@ -40,32 +38,36 @@ This library works best with one of these bundles below, but they're not require
 
 Test if a value is in a given array
 ```php
-$variables = ['foo' => 6];
+$variables = [
+    'coupon_code' => $_POST['coupon_code'],
+];
 
-$rule = new Rule('foo in [4, 6, 7]', $variables);
+$rule = new Rule('coupon_code in ["summer_discount", "summer21"]', $variables);
 var_dump($rule->isTrue()); // bool(true)
 ```
 
-Simple array manipulation 
+Performing a regular expression
 ```php
-$rule = new Rule('[1, 4, 3].join(".") === "1.4.3"');
+$variables = [
+    'coupon_code' => $_POST['coupon_code'],
+];
+
+$rule = new Rule('coupon_code.test(/^summer20[0-9]{2}$/) == true', $variables);
 var_dump($rule->isTrue()); // bool(true)
 ```
 
 Test if a value is between a given range
 ```php
-$variables = ['threshold' => 80];
+$variables = ['points' => 80];
 
-$rule = new Rule('threshold >= 50 && threshold <= 100', $variables);
+$rule = new Rule('points >= 50 && points <= 100', $variables);
 var_dump($rule->isTrue()); // bool(true)
 ```
 
 Call methods on objects from within rules
 ```php
 class User
 {
-    // ...
-
     public function points(): int
     {
         return 1337;    
@@ -180,7 +182,7 @@ $highlighter = new Rule\Highlighter\Highlighter(new Rule\Tokenizer());
 
 // Optional custom styles
 $highlighter->setStyle(
-    Rule\Constants::GROUP_VARIABLE,
+    TokenType::VARIABLE,
     'color: #007694; font-weight: 900;'
 );
 

composer.json

@@ -33,11 +33,11 @@
     }
   },
   "require": {
-    "php": ">=8.0"
+    "php": ">=8.1"
   },
   "require-dev": {
-    "phpunit/phpunit": "^7.0|^9.0",
-    "mockery/mockery": "^1.0|^1.4"
+    "phpunit/phpunit": "^9.5",
+    "mockery/mockery": "^1.4"
   },
   "scripts": {
     "test": "vendor/bin/phpunit"

src/Compiler/CompilerInterface.php

@@ -8,14 +8,16 @@
 namespace nicoSWD\Rule\Compiler;
 
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
+use nicoSWD\Rule\TokenStream\Token\Type\Logical;
+use nicoSWD\Rule\TokenStream\Token\Type\Parenthesis;
 
 interface CompilerInterface
 {
     public function getCompiledRule(): string;
 
-    public function addParentheses(BaseToken $token): void;
+    public function addParentheses(BaseToken & Parenthesis $token): void;
 
-    public function addLogical(BaseToken $token): void;
+    public function addLogical(BaseToken & Logical $token): void;
 
     public function addBoolean(bool $bool): void;
 }

src/Compiler/StandardCompiler.php

@@ -8,19 +8,17 @@
 namespace nicoSWD\Rule\Compiler;
 
 use nicoSWD\Rule\Compiler\Exception\MissingOperatorException;
+use nicoSWD\Rule\Evaluator\Boolean;
+use nicoSWD\Rule\Evaluator\Operator;
 use nicoSWD\Rule\Parser\Exception\ParserException;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\TokenAnd;
 use nicoSWD\Rule\TokenStream\Token\TokenOpeningParenthesis;
+use nicoSWD\Rule\TokenStream\Token\Type\Logical;
+use nicoSWD\Rule\TokenStream\Token\Type\Parenthesis;
 
-class StandardCompiler implements CompilerInterface
+final class StandardCompiler implements CompilerInterface
 {
-    private const BOOL_TRUE = '1';
-    private const BOOL_FALSE = '0';
-
-    private const LOGICAL_AND = '&';
-    private const LOGICAL_OR = '|';
-
     private const OPENING_PARENTHESIS = '(';
     private const CLOSING_PARENTHESIS = ')';
 
@@ -58,7 +56,7 @@ private function closeParenthesis(): void
     }
 
     /** @throws ParserException */
-    public function addParentheses(BaseToken $token): void
+    public function addParentheses(BaseToken & Parenthesis $token): void
     {
         if ($token instanceof TokenOpeningParenthesis) {
             if (!$this->expectOpeningParenthesis()) {
@@ -71,31 +69,27 @@ public function addParentheses(BaseToken $token): void
     }
 
     /** @throws ParserException */
-    public function addLogical(BaseToken $token): void
+    public function addLogical(BaseToken & Logical $token): void
     {
-        $lastChar = $this->getLastChar();
-
-        if ($lastChar === self::LOGICAL_AND || $lastChar === self::LOGICAL_OR) {
+        if (Operator::tryFrom($this->getLastChar()) !== null) {
             throw ParserException::unexpectedToken($token);
         }
 
         if ($token instanceof TokenAnd) {
-            $this->output .= self::LOGICAL_AND;
+            $this->output .= Operator::LOGICAL_AND->value;
         } else {
-            $this->output .= self::LOGICAL_OR;
+            $this->output .= Operator::LOGICAL_OR->value;
         }
     }
 
     /** @throws MissingOperatorException */
     public function addBoolean(bool $bool): void
     {
-        $lastChar = $this->getLastChar();
-
-        if ($lastChar === self::BOOL_TRUE || $lastChar === self::BOOL_FALSE) {
+        if (Boolean::tryFrom($this->getLastChar()) !== null) {
             throw new MissingOperatorException();
         }
 
-        $this->output .= $bool ? self::BOOL_TRUE : self::BOOL_FALSE;
+        $this->output .= Boolean::fromBool($bool)->value;
     }
 
     private function numParenthesesMatch(): bool
@@ -105,11 +99,7 @@ private function numParenthesesMatch(): bool
 
     private function isIncompleteCondition(): bool
     {
-        $lastChar = $this->getLastChar();
-
-        return
-            $lastChar === self::LOGICAL_AND ||
-            $lastChar === self::LOGICAL_OR;
+        return Operator::tryFrom($this->getLastChar()) !== null;
     }
 
     private function expectOpeningParenthesis(): bool
@@ -118,9 +108,8 @@ private function expectOpeningParenthesis(): bool
 
         return
             $lastChar === '' ||
-            $lastChar === self::LOGICAL_AND ||
-            $lastChar === self::LOGICAL_OR ||
-            $lastChar === self::OPENING_PARENTHESIS;
+            $lastChar === self::OPENING_PARENTHESIS ||
+            Operator::tryFrom($lastChar) !== null;
     }
 
     private function getLastChar(): string

src/Evaluator/Boolean.php

@@ -0,0 +1,19 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <[email protected]>
+ */
+namespace nicoSWD\Rule\Evaluator;
+
+enum Boolean: string
+{
+    case TRUE = '1';
+    case FALSE = '0';
+
+    final public static function fromBool(bool $bool): self
+    {
+        return $bool ? self::TRUE : self::FALSE;
+    }
+}

src/Evaluator/Evaluator.php

@@ -7,45 +7,42 @@
  */
 namespace nicoSWD\Rule\Evaluator;
 
+use Closure;
+
 final class Evaluator implements EvaluatorInterface
 {
-    private const LOGICAL_AND = '&';
-    private const LOGICAL_OR = '|';
-
-    private const BOOL_TRUE = '1';
-    private const BOOL_FALSE = '0';
-
     public function evaluate(string $group): bool
     {
         $evalGroup = $this->evalGroup();
         $count = 0;
 
         do {
             $group = preg_replace_callback(
-                '~\(([^()]+)\)~',
+                '~\((?<match>[^()]+)\)~',
                 $evalGroup,
                 $group,
                 limit: -1,
                 count: $count
             );
         } while ($count > 0);
 
-        return (bool) $evalGroup([1 => $group]);
+        return (bool) $evalGroup(['match' => $group]);
     }
 
-    private function evalGroup(): callable
+    private function evalGroup(): Closure
     {
         return function (array $group): ?int {
             $result = null;
             $operator = null;
             $offset = 0;
 
-            while (isset($group[1][$offset])) {
-                $value = $group[1][$offset++];
+            while (isset($group['match'][$offset])) {
+                $value = $group['match'][$offset++];
+                $possibleOperator = Operator::tryFrom($value);
 
-                if ($this->isLogical($value)) {
-                    $operator = $value;
-                } elseif ($this->isBoolean($value)) {
+                if ($possibleOperator) {
+                    $operator = $possibleOperator;
+                } elseif (Boolean::tryFrom($value)) {
                     $result = $this->setResult($result, (int) $value, $operator);
                 } else {
                     throw new Exception\UnknownSymbolException(sprintf('Unexpected "%s"', $value));
@@ -56,26 +53,16 @@ private function evalGroup(): callable
         };
     }
 
-    private function setResult(?int $result, int $value, ?string $operator): int
+    private function setResult(?int $result, int $value, ?Operator $operator): int
     {
         if (!isset($result)) {
             $result = $value;
-        } elseif ($operator === self::LOGICAL_AND) {
+        } elseif (Operator::isAnd($operator)) {
             $result &= $value;
-        } elseif ($operator === self::LOGICAL_OR) {
+        } elseif (Operator::isOr($operator)) {
             $result |= $value;
         }
 
         return $result;
     }
-
-    private function isLogical(string $value): bool
-    {
-        return $value === self::LOGICAL_AND || $value === self::LOGICAL_OR;
-    }
-
-    private function isBoolean(string $value): bool
-    {
-        return $value === self::BOOL_TRUE || $value === self::BOOL_FALSE;
-    }
 }

src/Evaluator/Exception/UnknownSymbolException.php

@@ -7,6 +7,6 @@
  */
 namespace nicoSWD\Rule\Evaluator\Exception;
 
-class UnknownSymbolException extends \Exception
+final class UnknownSymbolException extends \Exception
 {
 }

src/Evaluator/Operator.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+
+/**
+ * @license     http://opensource.org/licenses/mit-license.php MIT
+ * @link        https://github.com/nicoSWD
+ * @author      Nicolas Oelgart <[email protected]>
+ */
+namespace nicoSWD\Rule\Evaluator;
+
+enum Operator: string
+{
+    case LOGICAL_AND = '&';
+    case LOGICAL_OR = '|';
+
+    public static function isAnd(self $operator): bool
+    {
+        return $operator === self::LOGICAL_AND;
+    }
+
+    public static function isOr(self $operator): bool
+    {
+        return $operator === self::LOGICAL_OR;
+    }
+}