jclaveau / php-logical-filter

src/Rule/AndRule.php

Spacing +156 added lines, -156 removed lines

@@ -21,7 +21,7 @@ 
      */
     public function rootifyDisjunctions(array $simplification_options)
     {
-        if ( ! $this->isNormalizationAllowed($simplification_options)) {
+        if (!$this->isNormalizationAllowed($simplification_options)) {
             return $this;
         }
 
@@ -38,7 +38,7 @@ 
         }
 
         // If the AndRule doesn't contain any OrRule , there is nothing to uplift
-        if ( ! array_filter($upLiftedOperands, function($operand) {
+        if (!array_filter($upLiftedOperands, function($operand) {
             return $operand instanceof OrRule;
         })) {
             return new AndRule($upLiftedOperands);
@@ -56,11 +56,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 {
@@ -82,9 +82,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);
                         }
                     }
                 }
@@ -94,14 +94,14 @@ 
             else {
                 // append the operand to all the operands of the $upLiftedOr
                 foreach ($upLiftedOr->getOperands() as $upLifdtedOperand) {
-                    if ( ! $upLifdtedOperand instanceof AndRule) {
+                    if (!$upLifdtedOperand instanceof AndRule) {
                         throw new \LogicException(
                              "Operands of the uplifted OrRule MUST be AndRules during"
                             ."the combination."
                         );
                     }
 
-                    $upLifdtedOperand->addOperand( $operand->copy() );
+                    $upLifdtedOperand->addOperand($operand->copy());
                 }
             }
         }
@@ -116,7 +116,7 @@ 
      *
      * @todo same as OrRule
      */
-    public function toArray(array $options=[])
+    public function toArray(array $options = [])
     {
         $default_options = [
             'show_instance' => false,
@@ -124,12 +124,12 @@ 
             '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'])) {
+        if (!$options['show_instance'] && !empty($this->cache['array'])) {
             return $this->cache['array'];
         }
 
@@ -153,7 +153,7 @@ 
                 $operands_as_array[] = $operand->toArray($options);
             }
 
-            if ( ! $options['show_instance']) {
+            if (!$options['show_instance']) {
                 return $this->cache['array'] = $operands_as_array;
             }
             else {
@@ -164,10 +164,10 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         $operator = self::operator;
-        if ( ! $this->operands) {
+        if (!$this->operands) {
             return $this->cache['string'] = "['{$operator}']";
         }
 
@@ -179,7 +179,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 .= ']';
@@ -193,17 +193,17 @@ 
     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]);
 
@@ -211,7 +211,7 @@ 
             $has_been_changed = true;
         }
 
-        return ! empty($has_been_changed);
+        return !empty($has_been_changed);
     }
 
     /**
@@ -222,7 +222,7 @@ 
      */
     public function removeInvalidBranches(array $simplification_options)
     {
-        if ( ! $this->isNormalizationAllowed($simplification_options)) {
+        if (!$this->isNormalizationAllowed($simplification_options)) {
             return $this;
         }
 
@@ -230,9 +230,9 @@ 
 
         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()) {
+                if (!$this->operands[$i]->hasSolution()) {
                     $this->operands = [];
                     return $this;
                 }
@@ -244,8 +244,8 @@ 
         // $this->dump(true);
 
         foreach ($operandsByFields as $field => $operandsByOperator) {
-            if ( ! empty($operandsByOperator[ EqualRule::operator ])) {
-                foreach ($operandsByOperator[ EqualRule::operator ] as $equalRule) {
+            if (!empty($operandsByOperator[EqualRule::operator])) {
+                foreach ($operandsByOperator[EqualRule::operator] as $equalRule) {
                     // Multiple equal rules without the same value is invalid
                     if (isset($previousEqualRule) && $previousEqualRule->getValue() != $equalRule->getValue()) {
                         $this->operands = [];
@@ -255,55 +255,55 @@ 
                 }
                 unset($previousEqualRule);
 
-                $equalRule = reset($operandsByOperator[ EqualRule::operator ]);
+                $equalRule = reset($operandsByOperator[EqualRule::operator]);
 
-                if (   ! empty($operandsByOperator[ BelowRule::operator ])
+                if (!empty($operandsByOperator[BelowRule::operator])
                     && null === $equalRule->getValue()
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   ! empty($operandsByOperator[ BelowRule::operator ])
-                    && $equalRule->getValue() >= reset($operandsByOperator[ BelowRule::operator ])->getUpperLimit()
+                if (!empty($operandsByOperator[BelowRule::operator])
+                    && $equalRule->getValue() >= reset($operandsByOperator[BelowRule::operator])->getUpperLimit()
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   ! empty($operandsByOperator[ AboveRule::operator ])
+                if (!empty($operandsByOperator[AboveRule::operator])
                     && null === $equalRule->getValue()
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   ! empty($operandsByOperator[ AboveRule::operator ])
-                    && $equalRule->getValue() <= reset($operandsByOperator[ AboveRule::operator ])->getLowerLimit()
+                if (!empty($operandsByOperator[AboveRule::operator])
+                    && $equalRule->getValue() <= reset($operandsByOperator[AboveRule::operator])->getLowerLimit()
                 ) {
                     $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])
                     && null === $equalRule->getValue()
-                    && null === reset($operandsByOperator[ NotEqualRule::operator ])->getValue()
+                    && null === reset($operandsByOperator[NotEqualRule::operator])->getValue()
                 ) {
                     $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->getUpperLimit() <= $aboveRule->getLowerLimit()) {
                     $this->operands = [];
@@ -323,9 +323,9 @@ 
      *
      * @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)) {
+        if (!$this->simplicationStepReached(self::simplified)) {
             throw new \LogicException(
                 "hasSolution has no sens if the rule is not simplified instead of being at: "
                 .var_export($this->current_simplification_step, true)
@@ -334,12 +334,12 @@ 
 
         // atomic rules
         foreach ($this->getOperands() as $operand) {
-            if (method_exists($operand, 'hasSolution') && ! $operand->hasSolution()) {
+            if (method_exists($operand, 'hasSolution') && !$operand->hasSolution()) {
                 return false;
             }
         }
 
-        return ! empty($this->getOperands());
+        return !empty($this->getOperands());
     }
 
 
@@ -356,7 +356,7 @@ 
 
                 try {
                     if (AboveRule::operator == $operator) {
-                        usort($operands, function( AboveRule $a, AboveRule $b ) {
+                        usort($operands, function(AboveRule $a, AboveRule $b) {
                             if (null === $a->getLowerLimit()) {
                                 return 1;
                             }
@@ -374,7 +374,7 @@ 
                         $operands = [reset($operands)];
                     }
                     elseif (BelowRule::operator == $operator) {
-                        usort($operands, function( BelowRule $a, BelowRule $b ) {
+                        usort($operands, function(BelowRule $a, BelowRule $b) {
                             if (null === $a->getUpperLimit()) {
                                 return 1;
                             }
@@ -394,7 +394,7 @@ 
                     elseif (EqualRule::operator == $operator) {
                         // TODO add an option for the support strict comparison
                         foreach ($operands as $i => $operand) {
-                            if ( ! isset($previous_operand)) {
+                            if (!isset($previous_operand)) {
                                 $previous_operand = $operand;
                                 continue;
                             }
@@ -420,16 +420,16 @@ 
                                 continue;
                             }
 
-                            $first_in->setPossibilities( array_intersect(
+                            $first_in->setPossibilities(array_intersect(
                                 $first_in->getPossibilities(),
                                 $next_in->getPossibilities()
-                            ) );
+                            ));
 
                             unset($operands[$i]);
                         }
 
                         // [field in []] <=> false
-                        if ( ! $first_in->getPossibilities()) {
+                        if (!$first_in->getPossibilities()) {
                             return [];
                         }
                     }
@@ -441,17 +441,17 @@ 
                                 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)
@@ -461,7 +461,7 @@ 
                     throw $e;
                 }
 
-                $operandsByFields[ $field ][ $operator ] = $operands;
+                $operandsByFields[$field][$operator] = $operands;
             }
         }
 
@@ -484,14 +484,14 @@ 
                 ]
                 as $unifyable_operator
             ) {
-                if ( ! empty($operandsByOperator[ $unifyable_operator ])) {
-                    if (1 != count($operandsByOperator[ $unifyable_operator ])) {
+                if (!empty($operandsByOperator[$unifyable_operator])) {
+                    if (1 != count($operandsByOperator[$unifyable_operator])) {
                         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]"
                         );
                     }
@@ -502,7 +502,7 @@ 
             // If tyhere is no more operands for a given field it means there
             // is no possible solutions for it so all the current and_case
             // is invalidated.
-            if ( ! $operandsByOperator) {
+            if (!$operandsByOperator) {
                 return [];
             }
         }
@@ -517,73 +517,73 @@ 
     protected static function simplifyDifferentOperandsForField($field, array $operandsByOperator)
     {
         // EqualRule comparisons
-        if ( ! empty($operandsByOperator[ EqualRule::operator ])) {
-            $equalRule = reset( $operandsByOperator[ EqualRule::operator ] );
+        if (!empty($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 (null !== $equalRule->getValue()) {
                         if (null === $not_equal_rule->getValue()) { // 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 (null === $equalRule->getValue() ) {
+                    elseif (null === $equalRule->getValue()) {
                         if (null !== $not_equal_rule->getValue()) {
-                            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 ])) {
-                $aboveRule = reset($operandsByOperator[ AboveRule::operator ]);
+            if (!empty($operandsByOperator[AboveRule::operator])) {
+                $aboveRule = reset($operandsByOperator[AboveRule::operator]);
                 if (null !== $equalRule->getValue() && $aboveRule->getLowerLimit() < $equalRule->getValue()) {
-                    unset($operandsByOperator[ AboveRule::operator ]);
+                    unset($operandsByOperator[AboveRule::operator]);
                 }
             }
 
-            if ( ! empty($operandsByOperator[ BelowRule::operator ])) {
-                $belowRule = reset($operandsByOperator[ BelowRule::operator ]);
+            if (!empty($operandsByOperator[BelowRule::operator])) {
+                $belowRule = reset($operandsByOperator[BelowRule::operator]);
                 if (null !== $equalRule->getValue() && $belowRule->getUpperLimit() > $equalRule->getValue()) {
-                    unset($operandsByOperator[ BelowRule::operator ]);
+                    unset($operandsByOperator[BelowRule::operator]);
                 }
             }
 
-            if ( ! empty($operandsByOperator[ InRule::operator ])) {
-                $possibilities = reset($operandsByOperator[ InRule::operator ])->getPossibilities();
+            if (!empty($operandsByOperator[InRule::operator])) {
+                $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 ])) {
-                $notInRule = reset($operandsByOperator[ NotInRule::operator ]);
+            if (!empty($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 ])) {
-                $belowOrEqualRule = reset($operandsByOperator[ BelowOrEqualRule::operator ]);
+            if (!empty($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
@@ -591,10 +591,10 @@ 
                 }
             }
 
-            if ( ! empty($operandsByOperator[ AboveOrEqualRule::operator ])) {
-                $aboveOrEqualRule = reset($operandsByOperator[ AboveOrEqualRule::operator ]);
+            if (!empty($operandsByOperator[AboveOrEqualRule::operator])) {
+                $aboveOrEqualRule = reset($operandsByOperator[AboveOrEqualRule::operator]);
                 if ($equalRule->getValue() >= $aboveOrEqualRule->getMinimum()) {
-                    unset($operandsByOperator[ AboveOrEqualRule::operator ]);
+                    unset($operandsByOperator[AboveOrEqualRule::operator]);
                 }
                 else {
                     // ['field', '=', 4] && ['field', '<=', [3]...] <=> false
@@ -604,54 +604,54 @@ 
         }
 
         // 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 (null === $notEqualRule->getValue()) {
-                        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 (null !== reset($operandsByOperator[ EqualRule::operator ])->getValue()) {
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                        if (!empty($operandsByOperator[EqualRule::operator])) {
+                            if (null !== reset($operandsByOperator[EqualRule::operator])->getValue()) {
+                                unset($operandsByOperator[NotEqualRule::operator][$i]);
                             }
                         }
                     }
                     else {
-                        if ( ! empty($operandsByOperator[ AboveRule::operator ])) {
-                            if ($operandsByOperator[ AboveRule::operator ][0]->getLowerLimit() >= $notEqualRule->getValue()) {
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                        if (!empty($operandsByOperator[AboveRule::operator])) {
+                            if ($operandsByOperator[AboveRule::operator][0]->getLowerLimit() >= $notEqualRule->getValue()) {
+                                unset($operandsByOperator[NotEqualRule::operator][$i]);
                             }
                         }
 
-                        if ( ! empty($operandsByOperator[ BelowRule::operator ])) {
-                            if ($operandsByOperator[ BelowRule::operator ][0]->getUpperLimit() <= $notEqualRule->getValue()) {
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                        if (!empty($operandsByOperator[BelowRule::operator])) {
+                            if ($operandsByOperator[BelowRule::operator][0]->getUpperLimit() <= $notEqualRule->getValue()) {
+                                unset($operandsByOperator[NotEqualRule::operator][$i]);
                             }
                         }
                     }
 
-                    if ( ! empty($operandsByOperator[ NotInRule::operator ])) {
-                        $notInRule = reset($operandsByOperator[ NotInRule::operator ]);
-                        if ( ! in_array($notEqualRule->getValue(), $notInRule->getPossibilities())) {
+                    if (!empty($operandsByOperator[NotInRule::operator])) {
+                        $notInRule = reset($operandsByOperator[NotInRule::operator]);
+                        if (!in_array($notEqualRule->getValue(), $notInRule->getPossibilities())) {
                             // TODO Replace it by a FalseRule
-                            $operandsByOperator[ NotInRule::operator ][0]->setPossibilities(
+                            $operandsByOperator[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()])
                         );
                     }
@@ -661,61 +661,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 ])->getUpperLimit();
+            if (!empty($operandsByOperator[BelowRule::operator])) {
+                $upper_limit = reset($operandsByOperator[BelowRule::operator])->getUpperLimit();
 
-                $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 ])->getLowerLimit();
+            if (!empty($operandsByOperator[AboveRule::operator])) {
+                $lower_limit = reset($operandsByOperator[AboveRule::operator])->getLowerLimit();
 
-                $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 ])->getLowerLimit();
+            if (!empty($operandsByOperator[AboveRule::operator])) {
+                $lower_limit = reset($operandsByOperator[AboveRule::operator])->getLowerLimit();
 
-                $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;
                     } )
                 );
@@ -723,25 +723,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
@@ -749,8 +749,8 @@ 
                 }
             }
 
-            if ( ! empty($operandsByOperator[ AboveOrEqualRule::operator ])) {
-                $minimum = reset($operandsByOperator[ AboveOrEqualRule::operator ])->getMinimum();
+            if (!empty($operandsByOperator[AboveOrEqualRule::operator])) {
+                $minimum = reset($operandsByOperator[AboveOrEqualRule::operator])->getMinimum();
 
                 if ($belowOrEqualRule->getMaximum() < $minimum) {
                     // [field <= 3] && [field >= 4] <=> false
@@ -758,11 +758,11 @@ 
                 }
                 elseif ($belowOrEqualRule->getMaximum() == $minimum) {
                     // [field <= 3] && [field >= 3] <=> [field = 3]
-                    unset($operandsByOperator[ BelowOrEqualRule::operator ]);
-                    unset($operandsByOperator[ AboveOrEqualRule::operator ]);
-                    $operandsByOperator[ EqualRule::operator ][] = new EqualRule($field, $minimum);
+                    unset($operandsByOperator[BelowOrEqualRule::operator]);
+                    unset($operandsByOperator[AboveOrEqualRule::operator]);
+                    $operandsByOperator[EqualRule::operator][] = new EqualRule($field, $minimum);
 
-                    if (count($operandsByOperator[ EqualRule::operator ]) > 1) {
+                    if (count($operandsByOperator[EqualRule::operator]) > 1) {
                         $operandsByOperator = self::simplifyDifferentOperandsForField($field, $operandsByOperator);
                     }
                 }
@@ -781,10 +781,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);
         }
     }