jclaveau · jclaveau · Mar 7, 2026 · Mar 6, 2026
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
@@ -31,11 +31,23 @@ jobs:
         run: composer install --no-interaction
 
       - name: Run tests
-        run: php -d xdebug.mode=coverage ./vendor/bin/phpunit -c phpunit.ci.xml --coverage-clover=clover.xml
+        run: composer test:coverage -- --log-junit junit.xml
+
+      - name: list files
+        run: ls -l
+
+      - name: Upload test results to Codecov
+        if: ${{ !cancelled() }}
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          report_type: test_results
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
+        if: ${{ !cancelled() }}
+        uses: codecov/codecov-action@v5
         with:
-          files: ./clover.xml
-          flags: unittests
           name: php-${{ matrix.php-version }}
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: ./clover.xml
+          flags: tests
diff --git a/.gitignore b/.gitignore
@@ -1,10 +1,13 @@
 /vendor
 /.idea
-/tests_coverage
-/clover.xml
 /docs/phpdoc-*
-composer.lock
-.php_cs.cache
-.phpunit.result.cache
+/composer.lock
+
+/.phpunit.result.cache
 /coverage
-.php-cs-fixer.cache
+/tests_coverage
+/clover.xml
+/junit.xml
+/codecov
+
+/.php-cs-fixer.cache
diff --git a/composer.json b/composer.json
@@ -19,6 +19,7 @@
   "prefer-stable": true,
   "scripts": {
     "test": "phpunit",
+    "test:coverage": "XDEBUG_MODE=coverage phpunit",
     "lint": "./vendor/bin/php-cs-fixer check --diff",
     "lint:fix": "./vendor/bin/php-cs-fixer fix"
   },
@@ -60,7 +61,8 @@
     "jclaveau/xhprof": "dev-master",
     "jclaveau/phpunit-profile-asserts": "1.2.0",
     "dusank/knapsack": "^10.0",
-    "friendsofphp/php-cs-fixer": "^3.94"
+    "friendsofphp/php-cs-fixer": "^3.94",
+    "doctrine/sql-formatter": "^1.5"
   },
   "require": {
     "php": "^8.0",

diff --git a/phpunit.ci.xml b/phpunit.ci.xml
diff --git a/phpunit.xml b/phpunit.xml
@@ -21,6 +21,8 @@
         </include>
         <report>
             <html outputDirectory="coverage"/>
+            <clover outputFile="clover.xml"/>
+            <!-- <junit outputFile="junit.xml"/> -->
         </report>
     </coverage>
 

diff --git a/src/Converter/InlineSqlMinimalConverter.php b/src/Converter/InlineSqlMinimalConverter.php
@@ -53,9 +53,10 @@ public function addParameter($value) {
     public function convert(LogicalFilter $filter) {
         $this->output = [];
         parent::convert($filter);
+
         return [
             'sql' => ! $this->output
-                   ? '1' // True
+                   ? (! $this->simplifiedFilter ? 'TRUE' : 'FALSE')
                    : '('.implode(') OR (', $this->output).')',
             'parameters' => $this->parameters,
         ];
@@ -130,6 +131,9 @@ public function onAndPossibility($field, $operator, $rule, array $allOperandsByF
         elseif ('string' == gettype($value)) {
             $value = $this->addParameter($value);
         }
+        elseif ('boolean' == gettype($value)) {
+            $value = $value ? 'TRUE' : 'FALSE';
+        }
         elseif ('array' == gettype($value)) {
             $sql_part = [];
             foreach ($value as $possibility) {

diff --git a/src/Converter/MinimalConverter.php b/src/Converter/MinimalConverter.php
@@ -9,28 +9,32 @@
 
 use       JClaveau\LogicalFilter\Converter\ConverterInterface;
 use       JClaveau\LogicalFilter\LogicalFilter;
+use       JClaveau\LogicalFilter\Rule\AbstractOperationRule;
 
 /**
  * Basic tools to implements minimal converters: Converters that can
  * handle simplified filters with or/and/atomic structure.
  */
 abstract class MinimalConverter implements ConverterInterface {
+    protected ?AbstractOperationRule $simplifiedFilter = null;
+
     /**
      * @param LogicalFilter $filter
      */
     public function convert(LogicalFilter $filter) {
-        $rootOr = $filter->simplify(['force_logical_core' => true])->getRules();
+        $this->simplifiedFilter = $filter->simplify(['force_logical_core' => true])->getRules();
 
+        // Simplified filter with no rules
         // TODO remove this once TrueRule implemented https://github.com/jclaveau/php-logical-filter/issues/59
-        if (null === $rootOr) {
+        if (null === $this->simplifiedFilter) {
             return $this;
         }
 
-        if ( ! $rootOr->hasSolution()) {
+        if ( ! $this->simplifiedFilter->hasSolution()) {
             return $this;
         }
 
-        foreach ($rootOr->getOperands() as $andOperand) {
+        foreach ($this->simplifiedFilter->getOperands() as $andOperand) {
             $this->onOpenOr();
             $operandsByFields = $andOperand->groupOperandsByFieldAndOperator();
 

diff --git a/src/LogicalFilter.php b/src/LogicalFilter.php
@@ -797,10 +797,10 @@ public function applyOn($data_to_filter, $action_on_matches = null, $filterer =
     }
 
     /**
-     * Applies the current instance to a value (and its index optionnally).
+     * Applies the current instance to a value (and its index in an array optionnally).
      *
      * @param  mixed                  $value_to_check
-     * @param  scalar                 $index
+     * @param  scalar                 $key_to_check If a rule tests the index of an entry in an array
      * @param  Filterer|callable|null $filterer
      *
      * @return AbstractRule|false|true + False if the filter doesn't validates

diff --git a/src/Rule/AndRule.php b/src/Rule/AndRule.php
@@ -728,6 +728,7 @@ protected static function simplifyDifferentOperandsForField($field, array $opera
         if ( ! empty($operandsByOperator[BelowOrEqualRule::operator])) {
             $belowOrEqualRule = $operandsByOperator[BelowOrEqualRule::operator][0];
 
+            // with <
             if ( ! empty($operandsByOperator[BelowRule::operator])) {
                 $upper_limit = reset($operandsByOperator[BelowRule::operator])->getUpperLimit();
 
@@ -742,6 +743,7 @@ protected static function simplifyDifferentOperandsForField($field, array $opera
                 }
             }
 
+            // with >
             if ( ! empty($operandsByOperator[AboveRule::operator])) {
                 $lower_limit = reset($operandsByOperator[AboveRule::operator])->getLowerLimit();
 
@@ -751,6 +753,7 @@ protected static function simplifyDifferentOperandsForField($field, array $opera
                 }
             }
 
+            // with >=
             if ( ! empty($operandsByOperator[AboveOrEqualRule::operator])) {
                 $minimum = reset($operandsByOperator[AboveOrEqualRule::operator])->getMinimum();
 
@@ -771,6 +774,36 @@ protected static function simplifyDifferentOperandsForField($field, array $opera
             }
         }
 
+        // Comparison between >= and > or <
+        if ( ! empty($operandsByOperator[AboveOrEqualRule::operator])) {
+            $minimum_or_equal = reset($operandsByOperator[AboveOrEqualRule::operator])->getMinimum();
+
+            // with <
+            if ( ! empty($operandsByOperator[BelowRule::operator])) {
+                $upper_limit = reset($operandsByOperator[BelowRule::operator])->getUpperLimit();
+
+                if ($minimum_or_equal >= $upper_limit) {
+                    // [field < 3] && [field >= 4] <=> false
+                    return [];
+                }
+            }
+
+            // with >
+            if ( ! empty($operandsByOperator[AboveRule::operator])) {
+                $lower_limit = reset($operandsByOperator[AboveRule::operator])->getLowerLimit();
+
+                if ($minimum_or_equal >= $lower_limit) {
+                    // [field > 3] && [field >= 3]
+                    // [field > 3] && [field >= 4]
+                    unset($operandsByOperator[AboveOrEqualRule::operator][0]);
+                }
+                else {
+                    // [field > 3] && [field >= 2]
+                    unset($operandsByOperator[AboveRule::operator][0]);
+                }
+            }
+        }
+
         return $operandsByOperator;
     }