upgrade support for php81

Author: thomas-kl1

.gitignore

@@ -1,4 +1,6 @@
 /vendor/
 /docs/
 .php_cs.cache
+.phpunit.result.cache
+.idea
 composer.lock

README.md

@@ -39,17 +39,6 @@ This package is available through Composer/Packagist:
 composer require tklein/php-combine-conditions
 ```
 
-### Manual
-
-[Download](https://github.com/thomas-kl1/php-combine-conditions/zipball/master) this repo,
-or the [latest release](https://github.com/thomas-kl1/php-combine-conditions/releases),
-and put it somewhere in your project. Then do the following where you want to use the library:
-
-```php
-<?php
-require_once __DIR__.'/<path_where_it_has_been_extracted>/autoloader.php';
-```
-
 ## Getting Started
 
 The combine conditions library for PHP is a tool which helps you to build dynamically structured (as tree or graph) conditions.  
@@ -63,12 +52,12 @@ The library has been written in order to allows you to implement it to the right
 interfaces from the public API, you can build your own combine conditions structure and continue to execute it via the public
 API services.
 
-The library is written to follow the PSR1/PSR2 coding standards.
+The library is written to follow the PSR12 coding standards.
 
 ### Main Library Entrance
 
 For a simply use, you'll only need to use the following class: `\LogicTree\LogicTreeFacade`.  
-This class allows you to use the mainly features of the library, as to build a combined conditions, to execute somes, and
+This class allows you to use the mainly features of the library, as to build a combined conditions, to execute some, and
 exports them.
 
 ### OperatorPool
@@ -113,24 +102,24 @@ The library allows you to override the default operators and/or to provide new o
 $operatorPool = new \LogicTree\Operator\OperatorPool();
 
 $operatorPool->addOperator(
-    \LogicTree\Operator\OperatorPool::TYPE_LOGICAL,
+    \LogicTree\Operator\OperatorType::Logical,
     \LogicTree\Operator\Logical\AndOperator::CODE,
     new \My\Class\AndOperator()
 );
 $operatorPool->addOperator(
-    \LogicTree\Operator\OperatorPool::TYPE_COMPARATOR,
+    \LogicTree\Operator\OperatorType::Comparator,
     \LogicTree\Operator\Comparator\EqOperator::CODE,
     new \My\Class\EqOperator()
 );
 $operatorPool->addOperator(
-    \LogicTree\Operator\OperatorPool::TYPE_COMPARATOR,
+    \LogicTree\Operator\OperatorType::Comparator,
     'my_custom_operator',
     new \My\Class\MyCustomOperator()
 );
 
 $conditionManager = new \LogicTree\Service\ConditionManager($operatorPool);
 ```
-Now we are able to use these operators in our code and are availables everywhere in the library.
+Now we are able to use these operators in our code and are available everywhere in the library.
 
 ### Condition and Combine
 

composer.json

@@ -25,16 +25,16 @@
     },
     "prefer-stable": true,
     "require": {
-        "php": "^8.0"
+        "php": "^8.1"
     },
     "require-dev": {
         "phpunit/phpunit": "^9.5",
-        "phpmd/phpmd": "*",
-        "sebastian/phpcpd": "*",
-        "squizlabs/php_codesniffer": "*",
-        "friendsofphp/php-cs-fixer": "*",
-        "pdepend/pdepend": "*",
-        "phpstan/phpstan": "*"
+        "phpmd/phpmd": "^2.11",
+        "sebastian/phpcpd": "^6.0",
+        "squizlabs/php_codesniffer": "^3.6",
+        "friendsofphp/php-cs-fixer": "^3.4",
+        "pdepend/pdepend": "^2.1",
+        "phpstan/phpstan": "^1.3"
     },
     "autoload": {
         "psr-4": {

examples/index.php

@@ -11,6 +11,7 @@
 use LogicTree\Node\Condition;
 use LogicTree\Operator\OperatorInterface;
 use LogicTree\Operator\OperatorPool;
+use LogicTree\Operator\OperatorType;
 
 /**
  * Class CustomOperator
@@ -40,7 +41,7 @@ public function execute(...$expressions): bool
 $logicTree = new Combine('and', false, [$expr1, $expr2]);
 
 // Add new operator
-$logicTreeFacade->addOperator(OperatorPool::TYPE_COMPARATOR, 'custom_op', new CustomOperator());
+$logicTreeFacade->addOperator(OperatorType::Comparator, 'custom_op', new CustomOperator());
 
 // Execute combine conditions
 var_dump($logicTreeFacade->executeCombineConditions($logicTree, $dataSource));

src/DataSource.php

@@ -1,9 +1,8 @@
-<?php
+<?php declare(strict_types=1);
 /**
  * Copyright © Thomas Klein, All rights reserved.
  * See LICENSE bundled with this library for license details.
  */
-declare(strict_types=1);
 
 namespace LogicTree;
 

src/LogicTreeFacade.php

@@ -1,32 +1,31 @@
-<?php
+<?php declare(strict_types=1);
 /**
  * Copyright © Thomas Klein, All rights reserved.
  * See LICENSE bundled with this library for license details.
  */
-declare(strict_types=1);
 
 namespace LogicTree;
 
 use LogicTree\Node\NodeInterface;
 use LogicTree\Operator\OperatorInterface;
 use LogicTree\Operator\OperatorPool;
+use LogicTree\Operator\OperatorType;
 use LogicTree\Service\ConditionManager;
 
 class LogicTreeFacade
 {
-    private ConditionManager $conditionManager;
-
-    private OperatorPool $operatorPool;
-
-    public function __construct(?ConditionManager $conditionManager = null, ?OperatorPool $operatorPool = null)
-    {
+    public function __construct(
+        private ?ConditionManager $conditionManager = null,
+        private ?OperatorPool $operatorPool = null
+    ) {
         $this->operatorPool = $operatorPool ?? new OperatorPool();
         $this->conditionManager = $conditionManager ?? new ConditionManager($this->operatorPool);
     }
 
-    public function addOperator(string $type, string $operatorCode, OperatorInterface $operator): LogicTreeFacade
+    public function addOperator(OperatorType $type, string $operatorCode, OperatorInterface $operator): LogicTreeFacade
     {
         $this->operatorPool->addOperator($type, $operatorCode, $operator);
+
         return $this;
     }
 

src/Node/Combine.php

@@ -14,17 +14,12 @@ final class Combine extends AbstractNode implements CombineInterface
     /**
      * @var NodeInterface[]
      */
-    private array $nodes;
+    private array $nodes = [];
 
-    /**
-     * @param string $operator
-     * @param bool $isInvert [optional] Is false by default.
-     * @param NodeInterface[] $children [optional] Is empty by default.
-     */
     public function __construct(
         private string $operator,
         private bool $isInvert = false,
-        private array $children = []
+        array $children = []
     ) {
         $this->setOperator($operator);
         $this->setIsInvert($isInvert);

src/Node/Condition.php

@@ -8,25 +8,10 @@
 
 final class Condition extends AbstractNode implements ConditionInterface
 {
-    /**
-     * @var string
-     */
-    private $operator;
-
-    /**
-     * @var string
-     */
-    private $valueIdentifier;
-
-    /**
-     * @var mixed
-     */
-    private $valueCompare;
-
     public function __construct(
-        string $valueIdentifier,
-        string $operator,
-        $valueCompare
+        private string $valueIdentifier,
+        private string $operator,
+        private mixed $valueCompare
     ) {
         $this->setValueIdentifier($valueIdentifier);
         $this->setOperator($operator);
@@ -59,7 +44,7 @@ public function setValueIdentifier(string $identifier): ConditionInterface
 
     public function getValueCompare()
     {
-        return $this->valueCompare;
+        return $this->valueCompare;//ToDo: study to be fetched from datasource also?
     }
 
     public function setValueCompare($value): ConditionInterface

src/Operator/OperatorPool.php

@@ -41,86 +41,73 @@ final class OperatorPool
     public const TYPE_LOGICAL = 'logical';
     public const TYPE_COMPARATOR = 'comparator';
 
-    /**
-     * Default operators code and class name listed by types
-     *
-     * @var array
-     */
-    private const DEFAULT_OPERATORS = [
-        OperatorPool::TYPE_COMPARATOR => [
-            EmptyOperator::CODE => EmptyOperator::class,
-            EqOperator::CODE => EqOperator::class,
-            GteqOperator::CODE => GteqOperator::class,
-            GtOperator::CODE => GtOperator::class,
-            IdenOperator::CODE => IdenOperator::class,
-            InIdenOperator::CODE => InIdenOperator::class,
-            InOperator::CODE => InOperator::class,
-            LteqOperator::CODE => LteqOperator::class,
-            LtOperator::CODE => LtOperator::class,
-            NeqOperator::CODE => NeqOperator::class,
-            NidenOperator::CODE => NidenOperator::class,
-            NinIdenOperator::CODE => NinIdenOperator::class,
-            NinOperator::CODE => NinOperator::class,
-            NotNullOperator::CODE => NotNullOperator::class,
-            NullOperator::CODE => NullOperator::class,
-            RegexpOperator::CODE => RegexpOperator::class,
-        ],
-        OperatorPool::TYPE_LOGICAL => [
-            AndOperator::CODE => AndOperator::class,
-            OrOperator::CODE => OrOperator::class,
-            XorOperator::CODE => XorOperator::class,
-            NandOperator::CODE => NandOperator::class,
-            NorOperator::CODE => NorOperator::class,
-            XnorOperator::CODE => XnorOperator::class,
-        ],
-    ];
-
     /**
      * @var array[\LogicTree\Operator\OperatorInterface[]]
      */
-    private $operators = [];
+    private array $operators = [];
+
+    public static function defaultOperators(): array
+    {
+        return [
+            OperatorType::Comparator->value => [
+                EmptyOperator::CODE => EmptyOperator::class,
+                EqOperator::CODE => EqOperator::class,
+                GteqOperator::CODE => GteqOperator::class,
+                GtOperator::CODE => GtOperator::class,
+                IdenOperator::CODE => IdenOperator::class,
+                InIdenOperator::CODE => InIdenOperator::class,
+                InOperator::CODE => InOperator::class,
+                LteqOperator::CODE => LteqOperator::class,
+                LtOperator::CODE => LtOperator::class,
+                NeqOperator::CODE => NeqOperator::class,
+                NidenOperator::CODE => NidenOperator::class,
+                NinIdenOperator::CODE => NinIdenOperator::class,
+                NinOperator::CODE => NinOperator::class,
+                NotNullOperator::CODE => NotNullOperator::class,
+                NullOperator::CODE => NullOperator::class,
+                RegexpOperator::CODE => RegexpOperator::class,
+            ],
+            OperatorType::Logical->value => [
+                AndOperator::CODE => AndOperator::class,
+                OrOperator::CODE => OrOperator::class,
+                XorOperator::CODE => XorOperator::class,
+                NandOperator::CODE => NandOperator::class,
+                NorOperator::CODE => NorOperator::class,
+                XnorOperator::CODE => XnorOperator::class,
+            ],
+        ];
+    }
 
     public function __construct(array $operators = [])
     {
         $typeOperators = array_merge_recursive($this->retrieveDefaultOperators(), $operators);
 
         foreach ($typeOperators as $type => $operatorList) {
             foreach ($operatorList as $operatorCode => $operator) {
-                $this->addOperator($type, $operatorCode, $operator);
+                $this->addOperator(OperatorType::from($type), $operatorCode, $operator);
             }
         }
     }
 
-    public function getOperator(string $type, string $operatorCode): OperatorInterface
+    public function getOperator(OperatorType $type, string $operatorCode): OperatorInterface
     {
-        if (!isset($this->operators[$type][$operatorCode])) {
-            throw new LogicException(
-                sprintf('No registered operator for the type "%s" and code "%s".', $type, $operatorCode)
-            );
-        }
-
-        return $this->operators[$type][$operatorCode];
+        return $this->operators[$type->value][$operatorCode] ?? throw new LogicException(
+            sprintf('No registered operator for the type "%s" and code "%s".', $type, $operatorCode)
+        );
     }
 
-    public function addOperator(string $type, string $operatorCode, OperatorInterface $operator): OperatorPool
+    public function addOperator(OperatorType $type, string $operatorCode, OperatorInterface $operator): OperatorPool
     {
-        if (!isset($this->operators[$type][$operatorCode])) {
-            if (!isset($this->operators[$type])) {
-                $this->operators[$type] = [];
-            }
-
-            $this->operators[$type][$operatorCode] = $operator;
-        }
+        $this->operators[$type->value][$operatorCode] = $operator;
 
         return $this;
     }
 
     private function retrieveDefaultOperators(): array
     {
-        return array_map(static function ($operators) {
-            return array_map(static function ($operator) {
-                return new $operator();
-            }, $operators);
-        }, self::DEFAULT_OPERATORS);
+        return array_map(
+            static fn ($operators) => array_map(static fn ($operator) => new $operator(), $operators),
+            static::defaultOperators()
+        );
     }
 }

src/Operator/OperatorType.php

@@ -0,0 +1,13 @@
+<?php declare(strict_types=1);
+/**
+ * Copyright © OpenGento, All rights reserved.
+ */
+
+namespace LogicTree\Operator;
+
+enum OperatorType: string
+{
+    case Comparator = 'comparator';
+
+    case Logical = 'logical';
+}