jclaveau / php-logical-filter

src/Rule/AndRule.php

Spacing +133 added lines, -133 removed lines

@@ -24,7 +24,7 @@ 
         if (!$this->isNormalizationAllowed($simplification_options))
             return $this;
 
-        $this->moveSimplificationStepForward( self::rootify_disjunctions, $simplification_options );
+        $this->moveSimplificationStepForward(self::rootify_disjunctions, $simplification_options);
 
         $upLiftedOperands = [];
         foreach ($this->getOperands() as $operand) {
@@ -55,11 +55,11 @@ 
         foreach ($upLiftedOperands as $i => $operand) {
 
             if ($operand instanceof NotRule) {
-                if (    ($operand instanceof NotEqualRule || $operand instanceof NotInRule)
-                    && ! $operand->isNormalizationAllowed($simplification_options)
+                if (($operand instanceof NotEqualRule || $operand instanceof NotInRule)
+                    && !$operand->isNormalizationAllowed($simplification_options)
                 ) {
                     foreach ($upLiftedOr->getOperands() as $upLifdtedOperand) {
-                        $upLifdtedOperand->addOperand( $operand->copy() );
+                        $upLifdtedOperand->addOperand($operand->copy());
                     }
                 }
                 else {
@@ -81,9 +81,9 @@ 
                 foreach ($operand->getOperands() as $subOperand) {
                     foreach ($upLiftedOr->getOperands() as $upLiftedOrSubOperand) {
                         $newUpLiftedOrSubOperand = $upLiftedOrSubOperand->copy();
-                        $newUpLiftedOrSubOperand->addOperand( $subOperand->copy() );
+                        $newUpLiftedOrSubOperand->addOperand($subOperand->copy());
                         if ($newUpLiftedOrSubOperand->simplify($simplification_options)->hasSolution($simplification_options))
-                            $newUpLiftedOr->addOperand( $newUpLiftedOrSubOperand );
+                            $newUpLiftedOr->addOperand($newUpLiftedOrSubOperand);
                     }
                 }
 
@@ -99,7 +99,7 @@ 
                         );
                     }
 
-                    $upLifdtedOperand->addOperand( $operand->copy() );
+                    $upLifdtedOperand->addOperand($operand->copy());
                 }
             }
         }
@@ -114,7 +114,7 @@ 
      *
      * @todo same as OrRule
      */
-    public function toArray(array $options=[])
+    public function toArray(array $options = [])
     {
         $default_options = [
             'show_instance' => false,
@@ -122,8 +122,8 @@ 
             'semantic'      => false,
         ];
         foreach ($default_options as $default_option => &$default_value) {
-            if (!isset($options[ $default_option ]))
-                $options[ $default_option ] = $default_value;
+            if (!isset($options[$default_option]))
+                $options[$default_option] = $default_value;
         }
 
         if (!$options['show_instance'] && !empty($this->cache['array']))
@@ -157,7 +157,7 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         $operator = self::operator;
         if (!$this->operands) {
@@ -172,7 +172,7 @@ 
         foreach ($this->operands as $operand) {
             $out .= implode("\n", array_map(function($line) use (&$indent_unit) {
                 return $indent_unit.$line;
-            }, explode("\n", $operand->toString($options)) )) . ",$line_break";
+            }, explode("\n", $operand->toString($options)))).",$line_break";
         }
 
         $out .= ']';
@@ -186,15 +186,15 @@ 
     public function removeSameOperationOperands()
     {
         foreach ($this->operands as $i => $operand) {
-            if ( ! is_a($operand, AndRule::class))
+            if (!is_a($operand, AndRule::class))
                 continue;
 
-            if ( ! $operands = $operand->getOperands())
+            if (!$operands = $operand->getOperands())
                 continue;
 
             // Id AND is an operand on AND they can be merge (and the same with OR)
             foreach ($operands as $sub_operand) {
-                $this->addOperand( $sub_operand->copy() );
+                $this->addOperand($sub_operand->copy());
             }
             unset($this->operands[$i]);
 
@@ -220,7 +220,7 @@ 
 
         foreach ($this->operands as $i => $operand) {
             // if ($operand instanceof AndRule || $operand instanceof OrRule ) {
-            if ( in_array( get_class($operand), [AndRule::class, OrRule::class]) ) {
+            if (in_array(get_class($operand), [AndRule::class, OrRule::class])) {
                 $this->operands[$i] = $operand->removeInvalidBranches($simplification_options);
                 if (!$this->operands[$i]->hasSolution()) {
                     $this->operands = [];
@@ -235,9 +235,9 @@ 
 
         foreach ($operandsByFields as $field => $operandsByOperator) {
 
-            if (!empty($operandsByOperator[ EqualRule::operator ])) {
+            if (!empty($operandsByOperator[EqualRule::operator])) {
 
-                foreach ($operandsByOperator[ EqualRule::operator ] as $equalRule) {
+                foreach ($operandsByOperator[EqualRule::operator] as $equalRule) {
                     // Multiple equal rules without the same value is invalid
                     if (isset($previousEqualRule) && $previousEqualRule->getValue() != $equalRule->getValue()) {
                         $this->operands = [];
@@ -247,55 +247,55 @@ 
                 }
                 unset($previousEqualRule);
 
-                $equalRule = reset($operandsByOperator[ EqualRule::operator ]);
+                $equalRule = reset($operandsByOperator[EqualRule::operator]);
 
-                if (   !empty($operandsByOperator[ BelowRule::operator ])
+                if (!empty($operandsByOperator[BelowRule::operator])
                     && $equalRule->getValue() === null
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   !empty($operandsByOperator[ BelowRule::operator ])
-                    && $equalRule->getValue() >= reset($operandsByOperator[ BelowRule::operator ])->getMaximum()
+                if (!empty($operandsByOperator[BelowRule::operator])
+                    && $equalRule->getValue() >= reset($operandsByOperator[BelowRule::operator])->getMaximum()
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   !empty($operandsByOperator[ AboveRule::operator ])
+                if (!empty($operandsByOperator[AboveRule::operator])
                     && $equalRule->getValue() === null
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   !empty($operandsByOperator[ AboveRule::operator ])
-                    && $equalRule->getValue() <= reset($operandsByOperator[ AboveRule::operator ])->getMinimum()
+                if (!empty($operandsByOperator[AboveRule::operator])
+                    && $equalRule->getValue() <= reset($operandsByOperator[AboveRule::operator])->getMinimum()
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   !empty($operandsByOperator[ NotEqualRule::operator ])
-                    && $equalRule->getValue() == reset($operandsByOperator[ NotEqualRule::operator ])->getValue()
+                if (!empty($operandsByOperator[NotEqualRule::operator])
+                    && $equalRule->getValue() == reset($operandsByOperator[NotEqualRule::operator])->getValue()
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   !empty($operandsByOperator[ NotEqualRule::operator ])
+                if (!empty($operandsByOperator[NotEqualRule::operator])
                     && $equalRule->getValue() === null
-                    && reset($operandsByOperator[ NotEqualRule::operator ])->getValue() === null
+                    && reset($operandsByOperator[NotEqualRule::operator])->getValue() === null
                 ) {
                     $this->operands = [];
                     return $this;
                 }
             }
-            elseif (   !empty($operandsByOperator[ BelowRule::operator ])
-                    && !empty($operandsByOperator[ AboveRule::operator ])) {
-                $aboveRule = reset($operandsByOperator[ AboveRule::operator ]);
-                $belowRule = reset($operandsByOperator[ BelowRule::operator ]);
+            elseif (!empty($operandsByOperator[BelowRule::operator])
+                    && !empty($operandsByOperator[AboveRule::operator])) {
+                $aboveRule = reset($operandsByOperator[AboveRule::operator]);
+                $belowRule = reset($operandsByOperator[BelowRule::operator]);
 
                 if ($belowRule->getMaximum() <= $aboveRule->getMinimum()) {
                     $this->operands = [];
@@ -315,7 +315,7 @@ 
      *
      * @return bool If the AndRule can have a solution or not
      */
-    public function hasSolution(array $contextual_options=[])
+    public function hasSolution(array $contextual_options = [])
     {
         if (!$this->simplicationStepReached(self::simplified)) {
             throw new \LogicException(
@@ -348,7 +348,7 @@ 
 
                 try {
                     if ($operator == AboveRule::operator) {
-                        usort($operands, function( AboveRule $a, AboveRule $b ) {
+                        usort($operands, function(AboveRule $a, AboveRule $b) {
                             if ($a->getMinimum() === null)
                                 return 1;
 
@@ -363,7 +363,7 @@ 
                         $operands = [reset($operands)];
                     }
                     elseif ($operator == BelowRule::operator) {
-                        usort($operands, function( BelowRule $a, BelowRule $b ) {
+                        usort($operands, function(BelowRule $a, BelowRule $b) {
                             if ($a->getMaximum() === null)
                                 return 1;
 
@@ -405,10 +405,10 @@ 
                             if ($first_in === $next_in)
                                 continue;
 
-                            $first_in->setPossibilities( array_intersect(
+                            $first_in->setPossibilities(array_intersect(
                                 $first_in->getPossibilities(),
                                 $next_in->getPossibilities()
-                            ) );
+                            ));
 
                             unset($operands[$i]);
                         }
@@ -424,17 +424,17 @@ 
                             if ($first_not_in === $next_not_in)
                                 continue;
 
-                            $first_not_in->setPossibilities( array_merge(
+                            $first_not_in->setPossibilities(array_merge(
                                 $first_not_in->getPossibilities(),
                                 $next_not_in->getPossibilities()
-                            ) );
+                            ));
 
                             unset($operands[$i]);
                         }
                     }
                 }
                 catch (\Exception $e) {
-                    VisibilityViolator::setHiddenProperty($e, 'message', $e->getMessage() . "\n" . var_export([
+                    VisibilityViolator::setHiddenProperty($e, 'message', $e->getMessage()."\n".var_export([
                             'operands' => $operands,
                             // 'this'     => $this,
                         ], true)
@@ -444,7 +444,7 @@ 
                     throw $e;
                 }
 
-                $operandsByFields[ $field ][ $operator ] = $operands;
+                $operandsByFields[$field][$operator] = $operands;
             }
         }
 
@@ -468,14 +468,14 @@ 
                 ]
                 as $unifyable_operator
             ) {
-                if (!empty($operandsByOperator[ $unifyable_operator ])) {
-                    if (count($operandsByOperator[ $unifyable_operator ]) != 1) {
+                if (!empty($operandsByOperator[$unifyable_operator])) {
+                    if (count($operandsByOperator[$unifyable_operator]) != 1) {
                         throw new \LogicException(
-                            __METHOD__ . " MUST be called after unifyAtomicOperands() "
+                            __METHOD__." MUST be called after unifyAtomicOperands() "
                             ."to have only one '$unifyable_operator' predicate istead of:\n"
-                            ."[\n".implode( ",\n", array_map(function ($rule) {
+                            ."[\n".implode(",\n", array_map(function($rule) {
                                     return $rule->toString();
-                                }, $operandsByOperator[ $unifyable_operator ])
+                                }, $operandsByOperator[$unifyable_operator])
                             )."\n]"
                         );
                     }
@@ -483,79 +483,79 @@ 
             }
 
             // EqualRule comparisons
-            if (!empty($operandsByOperator[ EqualRule::operator ])) {
-                if (count($operandsByOperator[ EqualRule::operator ]) != 1) {
+            if (!empty($operandsByOperator[EqualRule::operator])) {
+                if (count($operandsByOperator[EqualRule::operator]) != 1) {
                     // Multiple Equal rules for one field with different values has no sense
                     continue;
                 }
 
-                $equalRule = reset( $operandsByOperator[ EqualRule::operator ] );
+                $equalRule = reset($operandsByOperator[EqualRule::operator]);
 
-                if (!empty($operandsByOperator[ NotEqualRule::operator ])) {
-                    foreach ($operandsByOperator[ NotEqualRule::operator ] as $i => $not_equal_rule) {
+                if (!empty($operandsByOperator[NotEqualRule::operator])) {
+                    foreach ($operandsByOperator[NotEqualRule::operator] as $i => $not_equal_rule) {
 
                         if ($equalRule->getValue() !== null) {
                             if ($not_equal_rule->getValue() === null) // means if exists <=> equals something
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                                unset($operandsByOperator[NotEqualRule::operator][$i]);
                             elseif ($not_equal_rule->getValue() != $equalRule->getValue())
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                                unset($operandsByOperator[NotEqualRule::operator][$i]);
                         }
-                        elseif ($equalRule->getValue() === null ) {
+                        elseif ($equalRule->getValue() === null) {
                             if ($not_equal_rule->getValue() !== null)
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                                unset($operandsByOperator[NotEqualRule::operator][$i]);
                             // else we let the "equal null" and the "not equal null" for the romeInvalidBranches step
                         }
                     }
                 }
 
-                if (!empty($operandsByOperator[ AboveRule::operator ])) {
+                if (!empty($operandsByOperator[AboveRule::operator])) {
 
-                    $aboveRule = reset($operandsByOperator[ AboveRule::operator ]);
+                    $aboveRule = reset($operandsByOperator[AboveRule::operator]);
                     if ($equalRule->getValue() !== null && $aboveRule->getMinimum() < $equalRule->getValue())
-                        unset($operandsByOperator[ AboveRule::operator ]);
+                        unset($operandsByOperator[AboveRule::operator]);
                 }
 
-                if (!empty($operandsByOperator[ BelowRule::operator ])) {
+                if (!empty($operandsByOperator[BelowRule::operator])) {
 
-                    $belowRule = reset($operandsByOperator[ BelowRule::operator ]);
+                    $belowRule = reset($operandsByOperator[BelowRule::operator]);
                     if ($equalRule->getValue() !== null && $belowRule->getMaximum() > $equalRule->getValue())
-                        unset($operandsByOperator[ BelowRule::operator ]);
+                        unset($operandsByOperator[BelowRule::operator]);
                 }
 
-                if (!empty($operandsByOperator[ InRule::operator ])) {
+                if (!empty($operandsByOperator[InRule::operator])) {
 
-                    $possibilities = reset($operandsByOperator[ InRule::operator ])->getPossibilities();
+                    $possibilities = reset($operandsByOperator[InRule::operator])->getPossibilities();
 
                     if (in_array($equalRule->getValue(), $possibilities)) {
-                        unset($operandsByOperator[ InRule::operator ]);
+                        unset($operandsByOperator[InRule::operator]);
                     }
                     else {
                         // We flush possibilities of the InRule
                         // TODO Replace it by a FalseRule
-                        $operandsByOperator[ InRule::operator ][0]->setPossibilities([]);
+                        $operandsByOperator[InRule::operator][0]->setPossibilities([]);
                         // and also remove the equal rule to shorten the reste of the simplification process
-                        unset($operandsByOperator[ EqualRule::operator ]);
+                        unset($operandsByOperator[EqualRule::operator]);
                     }
                 }
 
-                if (!empty($operandsByOperator[ NotInRule::operator ])) {
+                if (!empty($operandsByOperator[NotInRule::operator])) {
 
-                    $notInRule = reset($operandsByOperator[ NotInRule::operator ]);
+                    $notInRule = reset($operandsByOperator[NotInRule::operator]);
                     if (in_array($equalRule->getValue(), $notInRule->getPossibilities())) {
                         // ['field', '=', 4] && ['field', '!in', [4]...] <=> false
                         return [];
                     }
                     else {
-                        unset($operandsByOperator[ NotInRule::operator ]);
+                        unset($operandsByOperator[NotInRule::operator]);
                     }
                     // $notInRule->dump(true);
                 }
 
-                if (!empty($operandsByOperator[ BelowOrEqualRule::operator ])) {
+                if (!empty($operandsByOperator[BelowOrEqualRule::operator])) {
 
-                    $belowOrEqualRule = reset($operandsByOperator[ BelowOrEqualRule::operator ]);
+                    $belowOrEqualRule = reset($operandsByOperator[BelowOrEqualRule::operator]);
                     if ($equalRule->getValue() <= $belowOrEqualRule->getMaximum()) {
-                        unset($operandsByOperator[ BelowOrEqualRule::operator ]);
+                        unset($operandsByOperator[BelowOrEqualRule::operator]);
                     }
                     else {
                         // ['field', '=', 4] && ['field', '<=', [3]...] <=> false
@@ -565,52 +565,52 @@ 
             }
 
             // NotEqualRule null comparisons
-            if (!empty($operandsByOperator[ NotEqualRule::operator ])) {
-                if (!empty($operandsByOperator[ NotEqualRule::operator ])) {
-                    foreach ($operandsByOperator[ NotEqualRule::operator ] as $i => $notEqualRule) {
+            if (!empty($operandsByOperator[NotEqualRule::operator])) {
+                if (!empty($operandsByOperator[NotEqualRule::operator])) {
+                    foreach ($operandsByOperator[NotEqualRule::operator] as $i => $notEqualRule) {
 
                         if ($notEqualRule->getValue() === null) {
-                            if (!empty($operandsByOperator[ AboveRule::operator ])) {
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            if (!empty($operandsByOperator[AboveRule::operator])) {
+                                unset($operandsByOperator[NotEqualRule::operator][$i]);
                             }
 
-                            if (!empty($operandsByOperator[ BelowRule::operator ])) {
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            if (!empty($operandsByOperator[BelowRule::operator])) {
+                                unset($operandsByOperator[NotEqualRule::operator][$i]);
                             }
 
-                            if (!empty($operandsByOperator[ EqualRule::operator ])) {
-                                if (reset($operandsByOperator[ EqualRule::operator ])->getValue() !== null)
-                                    unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            if (!empty($operandsByOperator[EqualRule::operator])) {
+                                if (reset($operandsByOperator[EqualRule::operator])->getValue() !== null)
+                                    unset($operandsByOperator[NotEqualRule::operator][$i]);
                             }
                         }
                         else {
-                            if (!empty($operandsByOperator[ AboveRule::operator ])) {
-                                if ($operandsByOperator[ AboveRule::operator ][0]->getMinimum() >= $notEqualRule->getValue())
-                                    unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            if (!empty($operandsByOperator[AboveRule::operator])) {
+                                if ($operandsByOperator[AboveRule::operator][0]->getMinimum() >= $notEqualRule->getValue())
+                                    unset($operandsByOperator[NotEqualRule::operator][$i]);
                             }
 
-                            if (!empty($operandsByOperator[ BelowRule::operator ])) {
-                                if ($operandsByOperator[ BelowRule::operator ][0]->getMaximum() <= $notEqualRule->getValue())
-                                    unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            if (!empty($operandsByOperator[BelowRule::operator])) {
+                                if ($operandsByOperator[BelowRule::operator][0]->getMaximum() <= $notEqualRule->getValue())
+                                    unset($operandsByOperator[NotEqualRule::operator][$i]);
                             }
                         }
 
-                        if (!empty($operandsByOperator[ NotInRule::operator ])) {
-                            $notInRule = reset($operandsByOperator[ NotInRule::operator ]);
+                        if (!empty($operandsByOperator[NotInRule::operator])) {
+                            $notInRule = reset($operandsByOperator[NotInRule::operator]);
                             if (!in_array($notEqualRule->getValue(), $notInRule->getPossibilities())) {
                                 // TODO Replace it by a FalseRule
-                                $operandsByFields[ $field ][ NotInRule::operator ][0]->setPossibilities(
+                                $operandsByFields[$field][NotInRule::operator][0]->setPossibilities(
                                     array_merge($notInRule->getPossibilities(), [$notEqualRule->getValue()])
                                 );
                             }
 
-                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            unset($operandsByOperator[NotEqualRule::operator][$i]);
                         }
 
-                        if (!empty($operandsByOperator[ InRule::operator ])) {
-                            $inRule = reset($operandsByOperator[ InRule::operator ]);
+                        if (!empty($operandsByOperator[InRule::operator])) {
+                            $inRule = reset($operandsByOperator[InRule::operator]);
 
-                            $operandsByOperator[ InRule::operator ][0]->setPossibilities(
+                            $operandsByOperator[InRule::operator][0]->setPossibilities(
                                 array_diff($inRule->getPossibilities(), [$notEqualRule->getValue()])
                             );
                         }
@@ -620,61 +620,61 @@ 
 
             // Comparison between InRules and NotInRules
             // This is an optimization to avoid NotIn explosion
-            if (!empty($operandsByOperator[ InRule::operator ])) {
-                $inRule = $operandsByOperator[ InRule::operator ][0];
+            if (!empty($operandsByOperator[InRule::operator])) {
+                $inRule = $operandsByOperator[InRule::operator][0];
 
-                if (!empty($operandsByOperator[ NotInRule::operator ])) {
-                    $notInRule = reset($operandsByOperator[ NotInRule::operator ]);
-                    $operandsByOperator[ InRule::operator ][0]->setPossibilities(
-                        array_diff( $inRule->getPossibilities(), $notInRule->getPossibilities())
+                if (!empty($operandsByOperator[NotInRule::operator])) {
+                    $notInRule = reset($operandsByOperator[NotInRule::operator]);
+                    $operandsByOperator[InRule::operator][0]->setPossibilities(
+                        array_diff($inRule->getPossibilities(), $notInRule->getPossibilities())
                     );
-                    unset($operandsByOperator[ NotInRule::operator ]);
+                    unset($operandsByOperator[NotInRule::operator]);
                 }
 
-                if (!empty($operandsByOperator[ BelowRule::operator ])) {
-                    $upper_limit = reset($operandsByOperator[ BelowRule::operator ])->getMaximum();
+                if (!empty($operandsByOperator[BelowRule::operator])) {
+                    $upper_limit = reset($operandsByOperator[BelowRule::operator])->getMaximum();
 
-                    $operandsByOperator[ InRule::operator ][0]->setPossibilities(
-                        array_filter( $inRule->getPossibilities(), function ($possibility) use ($upper_limit) {
+                    $operandsByOperator[InRule::operator][0]->setPossibilities(
+                        array_filter($inRule->getPossibilities(), function($possibility) use ($upper_limit) {
                             return $possibility < $upper_limit;
                         } )
                     );
 
-                    unset($operandsByOperator[ BelowRule::operator ]);
+                    unset($operandsByOperator[BelowRule::operator]);
                 }
 
-                if (!empty($operandsByOperator[ AboveRule::operator ])) {
-                    $lower_limit = reset($operandsByOperator[ AboveRule::operator ])->getMinimum();
+                if (!empty($operandsByOperator[AboveRule::operator])) {
+                    $lower_limit = reset($operandsByOperator[AboveRule::operator])->getMinimum();
 
-                    $operandsByOperator[ InRule::operator ][0]->setPossibilities(
-                        array_filter( $inRule->getPossibilities(), function ($possibility) use ($lower_limit) {
+                    $operandsByOperator[InRule::operator][0]->setPossibilities(
+                        array_filter($inRule->getPossibilities(), function($possibility) use ($lower_limit) {
                             return $possibility > $lower_limit;
                         } )
                     );
 
-                    unset($operandsByOperator[ AboveRule::operator ]);
+                    unset($operandsByOperator[AboveRule::operator]);
                 }
             }
 
             // Comparison between NotInRules and > or <
-            if (!empty($operandsByOperator[ NotInRule::operator ])) {
-                $notInRule = $operandsByOperator[ NotInRule::operator ][0];
+            if (!empty($operandsByOperator[NotInRule::operator])) {
+                $notInRule = $operandsByOperator[NotInRule::operator][0];
 
-                if (!empty($operandsByOperator[ BelowRule::operator ])) {
-                    $upper_limit = reset($operandsByOperator[ BelowRule::operator ])->getUpperLimit();
+                if (!empty($operandsByOperator[BelowRule::operator])) {
+                    $upper_limit = reset($operandsByOperator[BelowRule::operator])->getUpperLimit();
 
-                    $operandsByOperator[ NotInRule::operator ][0]->setPossibilities(
-                        array_filter( $notInRule->getPossibilities(), function ($possibility) use ($upper_limit) {
+                    $operandsByOperator[NotInRule::operator][0]->setPossibilities(
+                        array_filter($notInRule->getPossibilities(), function($possibility) use ($upper_limit) {
                             return $possibility < $upper_limit;
                         } )
                     );
                 }
 
-                if (!empty($operandsByOperator[ AboveRule::operator ])) {
-                    $lower_limit = reset($operandsByOperator[ AboveRule::operator ])->getMinimum();
+                if (!empty($operandsByOperator[AboveRule::operator])) {
+                    $lower_limit = reset($operandsByOperator[AboveRule::operator])->getMinimum();
 
-                    $operandsByOperator[ NotInRule::operator ][0]->setPossibilities(
-                        array_filter( $notInRule->getPossibilities(), function ($possibility) use ($lower_limit) {
+                    $operandsByOperator[NotInRule::operator][0]->setPossibilities(
+                        array_filter($notInRule->getPossibilities(), function($possibility) use ($lower_limit) {
                             return $possibility > $lower_limit;
                         } )
                     );
@@ -682,25 +682,25 @@ 
             }
 
             // Comparison between <= and > or <
-            if (!empty($operandsByOperator[ BelowOrEqualRule::operator ])) {
-                $belowOrEqualRule = $operandsByOperator[ BelowOrEqualRule::operator ][0];
+            if (!empty($operandsByOperator[BelowOrEqualRule::operator])) {
+                $belowOrEqualRule = $operandsByOperator[BelowOrEqualRule::operator][0];
 
-                if (!empty($operandsByOperator[ BelowRule::operator ])) {
-                    $upper_limit = reset($operandsByOperator[ BelowRule::operator ])->getUpperLimit();
+                if (!empty($operandsByOperator[BelowRule::operator])) {
+                    $upper_limit = reset($operandsByOperator[BelowRule::operator])->getUpperLimit();
 
                     if ($belowOrEqualRule->getMaximum() >= $upper_limit) {
                         // [field < 3] && [field <= 3]
                         // [field < 3] && [field <= 4]
-                        unset($operandsByOperator[ BelowOrEqualRule::operator ][0]);
+                        unset($operandsByOperator[BelowOrEqualRule::operator][0]);
                     }
                     else {
                         // [field < 3] && [field <= 2]
-                        unset($operandsByOperator[ BelowRule::operator ][0]);
+                        unset($operandsByOperator[BelowRule::operator][0]);
                     }
                 }
 
-                if (!empty($operandsByOperator[ AboveRule::operator ])) {
-                    $lower_limit = reset($operandsByOperator[ AboveRule::operator ])->getLowerLimit();
+                if (!empty($operandsByOperator[AboveRule::operator])) {
+                    $lower_limit = reset($operandsByOperator[AboveRule::operator])->getLowerLimit();
 
                     if ($belowOrEqualRule->getMaximum() <= $lower_limit) {
                         // [field > 3] && [field <= 2] <=> false
@@ -722,10 +722,10 @@ 
     public function setOperandsOrReplaceByOperation($new_operands)
     {
         try {
-            return $this->setOperands( $new_operands );
+            return $this->setOperands($new_operands);
         }
         catch (\LogicException $e) {
-            return new AndRule( $new_operands );
+            return new AndRule($new_operands);
         }
     }
 

Braces +104 added lines, -94 removed lines

@@ -21,16 +21,18 @@ 
      */
     public function rootifyDisjunctions(array $simplification_options)
     {
-        if (!$this->isNormalizationAllowed($simplification_options))
-            return $this;
+        if (!$this->isNormalizationAllowed($simplification_options)) {
+                    return $this;
+        }
 
         $this->moveSimplificationStepForward( self::rootify_disjunctions, $simplification_options );
 
         $upLiftedOperands = [];
         foreach ($this->getOperands() as $operand) {
             $operand = $operand->copy();
-            if ($operand instanceof AbstractOperationRule)
-                $operand = $operand->rootifyDisjunctions($simplification_options);
+            if ($operand instanceof AbstractOperationRule) {
+                            $operand = $operand->rootifyDisjunctions($simplification_options);
+            }
 
             $upLiftedOperands[] = $operand;
         }
@@ -61,15 +63,13 @@ 
                     foreach ($upLiftedOr->getOperands() as $upLifdtedOperand) {
                         $upLifdtedOperand->addOperand( $operand->copy() );
                     }
-                }
-                else {
+                } else {
                     throw new \LogicException(
                         "Rootifying disjunctions MUST be done after negations removal instead of '".$operand."' \n"
                         .$operand
                     );
                 }
-            }
-            elseif ($operand instanceof OrRule && $operand->isNormalizationAllowed($simplification_options)) {
+            } elseif ($operand instanceof OrRule && $operand->isNormalizationAllowed($simplification_options)) {
 
                 // If an operand is an Or, me transform the current
                 // (A' || A") && (B')       <=> (A' && B') || (A" && B');
@@ -82,14 +82,14 @@ 
                     foreach ($upLiftedOr->getOperands() as $upLiftedOrSubOperand) {
                         $newUpLiftedOrSubOperand = $upLiftedOrSubOperand->copy();
                         $newUpLiftedOrSubOperand->addOperand( $subOperand->copy() );
-                        if ($newUpLiftedOrSubOperand->simplify($simplification_options)->hasSolution($simplification_options))
-                            $newUpLiftedOr->addOperand( $newUpLiftedOrSubOperand );
+                        if ($newUpLiftedOrSubOperand->simplify($simplification_options)->hasSolution($simplification_options)) {
+                                                    $newUpLiftedOr->addOperand( $newUpLiftedOrSubOperand );
+                        }
                     }
                 }
 
                 $upLiftedOr = $newUpLiftedOr;
-            }
-            else {
+            } else {
                 // append the operand to all the operands of the $upLiftedOr
                 foreach ($upLiftedOr->getOperands() as $upLifdtedOperand) {
                     if (!$upLifdtedOperand instanceof AndRule) {
@@ -122,12 +122,14 @@ 
             'semantic'      => false,
         ];
         foreach ($default_options as $default_option => &$default_value) {
-            if (!isset($options[ $default_option ]))
-                $options[ $default_option ] = $default_value;
+            if (!isset($options[ $default_option ])) {
+                            $options[ $default_option ] = $default_value;
+            }
         }
 
-        if (!$options['show_instance'] && !empty($this->cache['array']))
-            return $this->cache['array'];
+        if (!$options['show_instance'] && !empty($this->cache['array'])) {
+                    return $this->cache['array'];
+        }
 
         $operands_as_array = [
             $options['show_instance'] ? $this->getInstanceId() : self::operator,
@@ -143,15 +145,16 @@ 
                 [self::operator],
                 $operands_semantic_ids
             );
-        }
-        else {
-            foreach ($operands as $operand)
-                $operands_as_array[] = $operand->toArray($options);
-
-            if (!$options['show_instance'])
-                return $this->cache['array'] = $operands_as_array;
-            else
-                return $operands_as_array;
+        } else {
+            foreach ($operands as $operand) {
+                            $operands_as_array[] = $operand->toArray($options);
+            }
+
+            if (!$options['show_instance']) {
+                            return $this->cache['array'] = $operands_as_array;
+            } else {
+                            return $operands_as_array;
+            }
         }
     }
 
@@ -186,11 +189,13 @@ 
     public function removeSameOperationOperands()
     {
         foreach ($this->operands as $i => $operand) {
-            if ( ! is_a($operand, AndRule::class))
-                continue;
+            if ( ! is_a($operand, AndRule::class)) {
+                            continue;
+            }
 
-            if ( ! $operands = $operand->getOperands())
-                continue;
+            if ( ! $operands = $operand->getOperands()) {
+                            continue;
+            }
 
             // Id AND is an operand on AND they can be merge (and the same with OR)
             foreach ($operands as $sub_operand) {
@@ -213,8 +218,9 @@ 
      */
     public function removeInvalidBranches(array $simplification_options)
     {
-        if (!$this->isNormalizationAllowed($simplification_options))
-            return $this;
+        if (!$this->isNormalizationAllowed($simplification_options)) {
+                    return $this;
+        }
 
         $this->moveSimplificationStepForward(self::remove_invalid_branches, $simplification_options);
 
@@ -291,8 +297,7 @@ 
                     $this->operands = [];
                     return $this;
                 }
-            }
-            elseif (   !empty($operandsByOperator[ BelowRule::operator ])
+            } elseif (   !empty($operandsByOperator[ BelowRule::operator ])
                     && !empty($operandsByOperator[ AboveRule::operator ])) {
                 $aboveRule = reset($operandsByOperator[ AboveRule::operator ]);
                 $belowRule = reset($operandsByOperator[ BelowRule::operator ]);
@@ -326,8 +331,9 @@ 
 
         // atomic rules
         foreach ($this->getOperands() as $operand) {
-            if (method_exists($operand, 'hasSolution') && !$operand->hasSolution())
-                return false;
+            if (method_exists($operand, 'hasSolution') && !$operand->hasSolution()) {
+                            return false;
+            }
         }
 
         return !empty($this->getOperands());
@@ -349,35 +355,39 @@ 
                 try {
                     if ($operator == AboveRule::operator) {
                         usort($operands, function( AboveRule $a, AboveRule $b ) {
-                            if ($a->getMinimum() === null)
-                                return 1;
+                            if ($a->getMinimum() === null) {
+                                                            return 1;
+                            }
 
-                            if ($b->getMinimum() === null)
-                                return -1;
+                            if ($b->getMinimum() === null) {
+                                                            return -1;
+                            }
 
-                            if ($a->getMinimum() > $b->getMinimum())
-                                return -1;
+                            if ($a->getMinimum() > $b->getMinimum()) {
+                                                            return -1;
+                            }
 
                             return 1;
                         });
                         $operands = [reset($operands)];
-                    }
-                    elseif ($operator == BelowRule::operator) {
+                    } elseif ($operator == BelowRule::operator) {
                         usort($operands, function( BelowRule $a, BelowRule $b ) {
-                            if ($a->getMaximum() === null)
-                                return 1;
+                            if ($a->getMaximum() === null) {
+                                                            return 1;
+                            }
 
-                            if ($b->getMaximum() === null)
-                                return -1;
+                            if ($b->getMaximum() === null) {
+                                                            return -1;
+                            }
 
-                            if ($a->getMaximum() < $b->getMaximum())
-                                return -1;
+                            if ($a->getMaximum() < $b->getMaximum()) {
+                                                            return -1;
+                            }
 
                             return 1;
                         });
                         $operands = [reset($operands)];
-                    }
-                    elseif ($operator == EqualRule::operator) {
+                    } elseif ($operator == EqualRule::operator) {
                         // TODO add an option for the support strict comparison
                         foreach ($operands as $i => $operand) {
                             if (!isset($previous_operand)) {
@@ -388,8 +398,7 @@ 
                             if ($previous_operand == $operand) {
                                 unset($operands[$i]);
                                 continue;
-                            }
-                            else {
+                            } else {
                                 // Same field expected to be two differents
                                 // values at the same time has no sens so
                                 // we remove all the operands of the current
@@ -397,13 +406,13 @@ 
                                 return [];
                             }
                         }
-                    }
-                    elseif ($operator == InRule::operator) {
+                    } elseif ($operator == InRule::operator) {
                         $first_in = reset($operands);
 
                         foreach ($operands as $i => $next_in) {
-                            if ($first_in === $next_in)
-                                continue;
+                            if ($first_in === $next_in) {
+                                                            continue;
+                            }
 
                             $first_in->setPossibilities( array_intersect(
                                 $first_in->getPossibilities(),
@@ -414,15 +423,16 @@ 
                         }
 
                         // [field in []] <=> false
-                        if (!$first_in->getPossibilities())
-                            return [];
-                    }
-                    elseif ($operator == NotInRule::operator) {
+                        if (!$first_in->getPossibilities()) {
+                                                    return [];
+                        }
+                    } elseif ($operator == NotInRule::operator) {
                         $first_not_in = reset($operands);
 
                         foreach ($operands as $i => $next_not_in) {
-                            if ($first_not_in === $next_not_in)
-                                continue;
+                            if ($first_not_in === $next_not_in) {
+                                                            continue;
+                            }
 
                             $first_not_in->setPossibilities( array_merge(
                                 $first_not_in->getPossibilities(),
@@ -432,8 +442,7 @@ 
                             unset($operands[$i]);
                         }
                     }
-                }
-                catch (\Exception $e) {
+                } catch (\Exception $e) {
                     VisibilityViolator::setHiddenProperty($e, 'message', $e->getMessage() . "\n" . var_export([
                             'operands' => $operands,
                             // 'this'     => $this,
@@ -495,14 +504,16 @@ 
                     foreach ($operandsByOperator[ NotEqualRule::operator ] as $i => $not_equal_rule) {
 
                         if ($equalRule->getValue() !== null) {
-                            if ($not_equal_rule->getValue() === null) // means if exists <=> equals something
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
-                            elseif ($not_equal_rule->getValue() != $equalRule->getValue())
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
-                        }
-                        elseif ($equalRule->getValue() === null ) {
-                            if ($not_equal_rule->getValue() !== null)
+                            if ($not_equal_rule->getValue() === null) {
+                                // means if exists <=> equals something
                                 unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            } elseif ($not_equal_rule->getValue() != $equalRule->getValue()) {
+                                                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            }
+                        } elseif ($equalRule->getValue() === null ) {
+                            if ($not_equal_rule->getValue() !== null) {
+                                                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            }
                             // else we let the "equal null" and the "not equal null" for the romeInvalidBranches step
                         }
                     }
@@ -511,15 +522,17 @@ 
                 if (!empty($operandsByOperator[ AboveRule::operator ])) {
 
                     $aboveRule = reset($operandsByOperator[ AboveRule::operator ]);
-                    if ($equalRule->getValue() !== null && $aboveRule->getMinimum() < $equalRule->getValue())
-                        unset($operandsByOperator[ AboveRule::operator ]);
+                    if ($equalRule->getValue() !== null && $aboveRule->getMinimum() < $equalRule->getValue()) {
+                                            unset($operandsByOperator[ AboveRule::operator ]);
+                    }
                 }
 
                 if (!empty($operandsByOperator[ BelowRule::operator ])) {
 
                     $belowRule = reset($operandsByOperator[ BelowRule::operator ]);
-                    if ($equalRule->getValue() !== null && $belowRule->getMaximum() > $equalRule->getValue())
-                        unset($operandsByOperator[ BelowRule::operator ]);
+                    if ($equalRule->getValue() !== null && $belowRule->getMaximum() > $equalRule->getValue()) {
+                                            unset($operandsByOperator[ BelowRule::operator ]);
+                    }
                 }
 
                 if (!empty($operandsByOperator[ InRule::operator ])) {
@@ -528,8 +541,7 @@ 
 
                     if (in_array($equalRule->getValue(), $possibilities)) {
                         unset($operandsByOperator[ InRule::operator ]);
-                    }
-                    else {
+                    } else {
                         // We flush possibilities of the InRule
                         // TODO Replace it by a FalseRule
                         $operandsByOperator[ InRule::operator ][0]->setPossibilities([]);
@@ -544,8 +556,7 @@ 
                     if (in_array($equalRule->getValue(), $notInRule->getPossibilities())) {
                         // ['field', '=', 4] && ['field', '!in', [4]...] <=> false
                         return [];
-                    }
-                    else {
+                    } else {
                         unset($operandsByOperator[ NotInRule::operator ]);
                     }
                     // $notInRule->dump(true);
@@ -556,8 +567,7 @@ 
                     $belowOrEqualRule = reset($operandsByOperator[ BelowOrEqualRule::operator ]);
                     if ($equalRule->getValue() <= $belowOrEqualRule->getMaximum()) {
                         unset($operandsByOperator[ BelowOrEqualRule::operator ]);
-                    }
-                    else {
+                    } else {
                         // ['field', '=', 4] && ['field', '<=', [3]...] <=> false
                         return [];
                     }
@@ -579,19 +589,21 @@ 
                             }
 
                             if (!empty($operandsByOperator[ EqualRule::operator ])) {
-                                if (reset($operandsByOperator[ EqualRule::operator ])->getValue() !== null)
-                                    unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                                if (reset($operandsByOperator[ EqualRule::operator ])->getValue() !== null) {
+                                                                    unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                                }
                             }
-                        }
-                        else {
+                        } else {
                             if (!empty($operandsByOperator[ AboveRule::operator ])) {
-                                if ($operandsByOperator[ AboveRule::operator ][0]->getMinimum() >= $notEqualRule->getValue())
-                                    unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                                if ($operandsByOperator[ AboveRule::operator ][0]->getMinimum() >= $notEqualRule->getValue()) {
+                                                                    unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                                }
                             }
 
                             if (!empty($operandsByOperator[ BelowRule::operator ])) {
-                                if ($operandsByOperator[ BelowRule::operator ][0]->getMaximum() <= $notEqualRule->getValue())
-                                    unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                                if ($operandsByOperator[ BelowRule::operator ][0]->getMaximum() <= $notEqualRule->getValue()) {
+                                                                    unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                                }
                             }
                         }
 
@@ -692,8 +704,7 @@ 
                         // [field < 3] && [field <= 3]
                         // [field < 3] && [field <= 4]
                         unset($operandsByOperator[ BelowOrEqualRule::operator ][0]);
-                    }
-                    else {
+                    } else {
                         // [field < 3] && [field <= 2]
                         unset($operandsByOperator[ BelowRule::operator ][0]);
                     }
@@ -723,8 +734,7 @@ 
     {
         try {
             return $this->setOperands( $new_operands );
-        }
-        catch (\LogicException $e) {
+        } catch (\LogicException $e) {
             return new AndRule( $new_operands );
         }
     }

src/Rule/BelowOrEqualRule.php

Spacing +9 added lines, -9 removed lines

@@ -18,7 +18,7 @@ 
      * @param string $field The field to apply the rule on.
      * @param array  $value The value the field can below to.
      */
-    public function __construct($field, $maximum, array $options=[])
+    public function __construct($field, $maximum, array $options = [])
     {
         if (!empty($options)) {
             $this->setOptions($options);
@@ -62,7 +62,7 @@ 
     /**
      * @return bool
      */
-    public function isNormalizationAllowed(array $contextual_options=[])
+    public function isNormalizationAllowed(array $contextual_options = [])
     {
         return $this->getOption('below_or_equal.normalization', $contextual_options);
     }
@@ -72,7 +72,7 @@ 
      */
     public function getOperands()
     {
-        if (! empty($this->cache['operands'])) {
+        if (!empty($this->cache['operands'])) {
             return $this->cache['operands'];
         }
 
@@ -104,7 +104,7 @@ 
             }
         }
 
-        if (    count($operands) != 2
+        if (count($operands) != 2
             || !isset($equalRuleValue)
             || !isset($belowRuleValue)
             || $belowRuleValue != $equalRuleValue
@@ -135,14 +135,14 @@ 
      *
      * @return array
      */
-    public function toArray(array $options=[])
+    public function toArray(array $options = [])
     {
         $default_options = [
             'show_instance' => false,
         ];
         foreach ($default_options as $default_option => &$default_value) {
-            if (!isset($options[ $default_option ]))
-                $options[ $default_option ] = $default_value;
+            if (!isset($options[$default_option]))
+                $options[$default_option] = $default_value;
         }
 
         try {
@@ -160,14 +160,14 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         if (isset($this->cache['string']))
             return $this->cache['string'];
 
         $operator = self::operator;
 
-        return $this->cache['string'] = "['{$this->getField()}', '$operator', " . var_export($this->getValues(), true). "]";
+        return $this->cache['string'] = "['{$this->getField()}', '$operator', ".var_export($this->getValues(), true)."]";
     }
 
     /**/

Braces +11 added lines, -10 removed lines

@@ -50,8 +50,9 @@ 
             );
         }
 
-        if ($this->maximum == $maximum)
-            return $this;
+        if ($this->maximum == $maximum) {
+                    return $this;
+        }
 
         $this->maximum = $maximum;
         $this->flushCache();
@@ -97,8 +98,7 @@ 
             if ($operand instanceof EqualRule) {
                 $equalRuleField = $operand->getField();
                 $equalRuleValue = $operand->getValue();
-            }
-            elseif ($operand instanceof BelowRule) {
+            } elseif ($operand instanceof BelowRule) {
                 $belowRuleField = $operand->getField();
                 $belowRuleValue = $operand->getUpperLimit();
             }
@@ -141,8 +141,9 @@ 
             'show_instance' => false,
         ];
         foreach ($default_options as $default_option => &$default_value) {
-            if (!isset($options[ $default_option ]))
-                $options[ $default_option ] = $default_value;
+            if (!isset($options[ $default_option ])) {
+                            $options[ $default_option ] = $default_value;
+            }
         }
 
         try {
@@ -152,8 +153,7 @@ 
                 $options['show_instance'] ? $this->getInstanceId() : self::operator,
                 $this->getValues(),
             ];
-        }
-        catch (\RuntimeException $e) {
+        } catch (\RuntimeException $e) {
             return parent::toArray();
         }
     }
@@ -162,8 +162,9 @@ 
      */
     public function toString(array $options=[])
     {
-        if (isset($this->cache['string']))
-            return $this->cache['string'];
+        if (isset($this->cache['string'])) {
+                    return $this->cache['string'];
+        }
 
         $operator = self::operator;