POC formatter for combine condition

Author: thomas-kl1

README.md

@@ -98,12 +98,13 @@ The library allows you to override the default operators and/or to provide new o
 - Finally, pass the `OperatorPool` object in the construct of the `ConditionManager` class.
 
 *Eg: In the following example, we override the default comparators with ours and add a new one.*
+
 ```php
 $operatorPool = new \LogicTree\Operator\OperatorPool();
 
 $operatorPool->addOperator(
     \LogicTree\Operator\OperatorType::Logical,
-    \LogicTree\Operator\Logical\AndOperator::CODE,
+    \LogicTree\Operator\Logical\LogicalOperatorConverter::CODE,
     new \My\Class\AndOperator()
 );
 $operatorPool->addOperator(

examples/index.php

@@ -6,11 +6,12 @@
 
 require_once dirname(__DIR__) . '/vendor/autoload.php';
 
+use LogicTree\Formatter\ConverterInterface;
+use LogicTree\Formatter\NaturalFormatter;
 use LogicTree\LogicTreeFacade;
 use LogicTree\Node\Combine;
 use LogicTree\Node\Condition;
 use LogicTree\Operator\OperatorInterface;
-use LogicTree\Operator\OperatorPool;
 use LogicTree\Operator\OperatorType;
 
 /**
@@ -29,6 +30,14 @@ public function execute(...$expressions): bool
     }
 }
 
+class CustomOpConverter implements  ConverterInterface
+{
+    public function convert(...$expressions): string
+    {
+        return 'SUM(' . implode(', ', $expressions) . ') > 5';
+    }
+}
+
 /**
  * USE CASES
  */
@@ -45,3 +54,8 @@ public function execute(...$expressions): bool
 
 // Execute combine conditions
 var_dump($logicTreeFacade->executeCombineConditions($logicTree, $dataSource));
+
+$formatter = new NaturalFormatter();
+$formatter->register('custom_op', new CustomOpConverter());
+echo '<hr>';
+echo $formatter->format($logicTree, $dataSource);

src/Formatter/ConverterInterface.php

@@ -0,0 +1,15 @@
+<?php declare(strict_types=1);
+/**
+ * Copyright © Thomas Klein, All rights reserved.
+ * See LICENSE bundled with this library for license details.
+ */
+
+namespace LogicTree\Formatter;
+
+/**
+ * @api
+ */
+interface ConverterInterface
+{
+    public function convert(mixed ...$expressions): string;
+}

src/Formatter/FormatterInterface.php

@@ -0,0 +1,20 @@
+<?php declare(strict_types=1);
+/**
+ * Copyright © Thomas Klein, All rights reserved.
+ * See LICENSE bundled with this library for license details.
+ */
+
+namespace LogicTree\Formatter;
+
+use LogicTree\DataSource;
+use LogicTree\Node\NodeInterface;
+
+/**
+ * @api
+ */
+interface FormatterInterface
+{
+    public function format(NodeInterface $node, DataSource $dataSource): string;
+
+    public function register(string $operator, ConverterInterface $converter): void;
+}

src/Formatter/Natural/Comparator/CompareListConverter.php

@@ -0,0 +1,30 @@
+<?php declare(strict_types=1);
+/**
+ * Copyright © Thomas Klein, All rights reserved.
+ * See LICENSE bundled with this library for license details.
+ */
+
+namespace LogicTree\Formatter\Natural\Comparator;
+
+use InvalidArgumentException;
+use LogicTree\Formatter\ConverterInterface;
+
+use function var_export;
+
+final class CompareListConverter implements ConverterInterface
+{
+    public function __construct(private string $comparator) {}
+
+    public function convert(mixed ...$expressions): string
+    {
+        $count = count($expressions);
+
+        if ($count !== 2) {
+            throw new InvalidArgumentException('2 expressions expected, ' . $count . ' given.');
+        }
+
+        [$expr1, $expr2] = $expressions;
+
+        return var_export($expr1, true) . ' ' . $this->comparator . ' (' . var_export($expr2, true) . ')';
+    }
+}

src/Formatter/Natural/Comparator/CompareOneConverter.php

@@ -0,0 +1,28 @@
+<?php declare(strict_types=1);
+/**
+ * Copyright © Thomas Klein, All rights reserved.
+ * See LICENSE bundled with this library for license details.
+ */
+
+namespace LogicTree\Formatter\Natural\Comparator;
+
+use InvalidArgumentException;
+use LogicTree\Formatter\ConverterInterface;
+
+use function var_export;
+
+final class CompareOneConverter implements ConverterInterface
+{
+    public function __construct(private string $comparator) {}
+
+    public function convert(mixed ...$expressions): string
+    {
+        $count = count($expressions);
+
+        if ($count !== 1) {
+            throw new InvalidArgumentException('1 expression expected, ' . $count . ' given.');
+        }
+
+        return var_export($expressions[0], true) . ' ' . $this->comparator;
+    }
+}

src/Formatter/Natural/Comparator/CompareTwoConverter.php

@@ -0,0 +1,28 @@
+<?php declare(strict_types=1);
+/**
+ * Copyright © Thomas Klein, All rights reserved.
+ * See LICENSE bundled with this library for license details.
+ */
+
+namespace LogicTree\Formatter\Natural\Comparator;
+
+use InvalidArgumentException;
+use LogicTree\Formatter\ConverterInterface;
+
+use function var_export;
+
+final class CompareTwoConverter implements ConverterInterface
+{
+    public function __construct(private string $comparator) {}
+
+    public function convert(mixed ...$expressions): string
+    {
+        $count = count($expressions);
+
+        if ($count !== 2) {
+            throw new InvalidArgumentException('2 expressions expected, ' . $count . ' given.');
+        }
+
+        return var_export($expressions[0], true) . ' ' . $this->comparator . ' ' . var_export($expressions[1], true);
+    }
+}

src/Formatter/Natural/Logical/LogicalOperatorConverter.php

@@ -0,0 +1,21 @@
+<?php declare(strict_types=1);
+/**
+ * Copyright © Thomas Klein, All rights reserved.
+ * See LICENSE bundled with this library for license details.
+ */
+
+namespace LogicTree\Formatter\Natural\Logical;
+
+use LogicTree\Formatter\ConverterInterface;
+
+use function implode;
+
+final class LogicalOperatorConverter implements ConverterInterface
+{
+    public function __construct(private string $symbol) {}
+
+    public function convert(mixed ...$expressions): string
+    {
+        return '(' . implode(' ' . $this->symbol . ' ', $expressions) . ')';
+    }
+}

src/Formatter/NaturalFormatter.php

@@ -0,0 +1,81 @@
+<?php declare(strict_types=1);
+/**
+ * Copyright © Thomas Klein, All rights reserved.
+ * See LICENSE bundled with this library for license details.
+ */
+
+namespace LogicTree\Formatter;
+
+use LogicTree\DataSource;
+use LogicTree\Formatter\Natural\Comparator\CompareListConverter;
+use LogicTree\Formatter\Natural\Comparator\CompareOneConverter;
+use LogicTree\Formatter\Natural\Comparator\CompareTwoConverter;
+use LogicTree\Formatter\Natural\Logical\LogicalOperatorConverter;
+use LogicTree\Node\CombineInterface;
+use LogicTree\Node\ConditionInterface;
+use LogicTree\Node\NodeInterface;
+
+use function array_map;
+
+final class NaturalFormatter implements FormatterInterface
+{
+    /**
+     * @var ConverterInterface[]
+     */
+    private array $converters = [];
+
+    public function __construct()
+    {
+        $this->register('empty', new CompareOneConverter('IS EMPTY'));
+        $this->register('eq', new CompareTwoConverter('=='));
+        $this->register('gteq', new CompareTwoConverter('>='));
+        $this->register('gt', new CompareTwoConverter('>'));
+        $this->register('iden', new CompareTwoConverter('==='));
+        $this->register('iniden', new CompareTwoConverter('IN STRICT'));
+        $this->register('in', new CompareTwoConverter('IN'));
+        $this->register('lteq', new CompareTwoConverter('<='));
+        $this->register('lt', new CompareTwoConverter('<'));
+        $this->register('neq', new CompareTwoConverter('!='));
+        $this->register('niden', new CompareTwoConverter('!=='));
+        $this->register('niniden', new CompareTwoConverter('NOT IN STRICT'));
+        $this->register('nin', new CompareListConverter('NOT IN'));
+        $this->register('notnull', new CompareOneConverter('IS NOT NULL'));
+        $this->register('null', new CompareOneConverter('IS NULL'));
+        $this->register('regexp', new CompareTwoConverter('MATCH REGEX'));
+        $this->register('and', new LogicalOperatorConverter('AND'));
+        $this->register('nand', new LogicalOperatorConverter('NAND'));
+        $this->register('nor', new LogicalOperatorConverter('NOR'));
+        $this->register('or', new LogicalOperatorConverter('OR'));
+        $this->register('xnor', new LogicalOperatorConverter('XNOR'));
+        $this->register('xor', new LogicalOperatorConverter('XOR'));
+    }
+
+    public function register(string $operator, ConverterInterface $converter): void
+    {
+        $this->converters[$operator] = $converter;
+    }
+
+    public function format(NodeInterface $node, DataSource $dataSource): string
+    {
+        return match (true) {
+            $node instanceof CombineInterface => $this->formatCombine($node, $dataSource),
+            $node instanceof ConditionInterface => $this->formatCondition($node, $dataSource),
+            default => throw new \Exception()//ToDo
+        };
+    }
+
+    private function formatCombine(CombineInterface $combine, DataSource $dataSource): string
+    {
+        return ($combine->isInvert() ? 'NOT ' : '') . $this->converters[$combine->getOperator()]->convert(
+            ...array_map(fn (NodeInterface $node) => $this->format($node, $dataSource), $combine->getChildren())
+        );
+    }
+
+    private function formatCondition(ConditionInterface $condition, DataSource $dataSource): string
+    {//ToDo exception if not exists
+        return $this->converters[$condition->getOperator()]->convert(
+            $dataSource->getValue($condition->getValueIdentifier()),
+            $condition->getValueCompare()
+        );
+    }
+}

src/Node/CombineInterface.php

@@ -21,44 +21,30 @@ public function getChildren(): array;
      * Set the logic structure as conditions or combinations
      *
      * @param NodeInterface[] $children
-     * @return Combine
      */
     public function setChildren(array $children): CombineInterface;
 
     /**
      * Add a logic structure as condition or combination
      *
      * @param NodeInterface $node
-     * @return Combine
      */
     public function addChild(NodeInterface $node): CombineInterface;
 
     /**
      * Retrieve the count of children nodes
-     *
-     * @return int
      */
     public function getCount(): int;
 
-    /**
-     * Check if it has children
-     *
-     * @return bool
-     */
     public function hasChildren(): bool;
 
     /**
      * Check if the result should be inverted
-     *
-     * @return bool
      */
     public function isInvert(): bool;
 
     /**
      * Set is result of combination inverted
-     *
-     * @param bool $isInvert
-     * @return Combine
      */
     public function setIsInvert(bool $isInvert): CombineInterface;
 }