jclaveau / php-logical-filter

src/LogicalFilter.php

Spacing +67 added lines, -67 removed lines

@@ -51,7 +51,7 @@ 
      *
      * @see self::addRules
      */
-    public function __construct($rules=[], Filterer $default_filterer=null, array $options=[])
+    public function __construct($rules = [], Filterer $default_filterer = null, array $options = [])
     {
         if ($rules instanceof AbstractRule) {
             $rules = $rules->copy();
@@ -72,7 +72,7 @@ 
         }
 
         if ($rules) {
-            $this->and_( $rules );
+            $this->and_($rules);
         }
     }
 
@@ -138,7 +138,7 @@ 
      * @param  array         $rules_description Rules description
      * @return LogicalFilter $this
      */
-    protected function addRules( $operation, array $rules_description )
+    protected function addRules($operation, array $rules_description)
     {
         if ($rules_description == [null]) {
             // TODO this is due to the bad design of using "Null" instead of
@@ -161,7 +161,7 @@ 
             }
         }
 
-        if (   3 == count($rules_description)
+        if (3 == count($rules_description)
             && is_string($rules_description[0])
             && is_string($rules_description[1])
         ) {
@@ -177,30 +177,30 @@ 
         }
         elseif (count($rules_description) == count(array_filter($rules_description, function($arg) {
             return $arg instanceof LogicalFilter;
-        })) ) {
+        }))) {
             // Already instanciated rules
             foreach ($rules_description as $i => $filter) {
                 $rules = $filter->getRules();
                 if (null !== $rules) {
-                    $this->addRule( $rules, $operation);
+                    $this->addRule($rules, $operation);
                 }
             }
         }
         elseif (count($rules_description) == count(array_filter($rules_description, function($arg) {
             return $arg instanceof AbstractRule;
-        })) ) {
+        }))) {
             // Already instanciated rules
             foreach ($rules_description as $i => $new_rule) {
-                $this->addRule( $new_rule, $operation);
+                $this->addRule($new_rule, $operation);
             }
         }
         elseif (1 == count($rules_description) && is_array($rules_description[0])) {
             if (count($rules_description[0]) == count(array_filter($rules_description[0], function($arg) {
                 return $arg instanceof AbstractRule;
-            })) ) {
+            }))) {
                 // Case of $filter->or_([AbstractRule, AbstractRule, AbstractRule, ...])
                 foreach ($rules_description[0] as $i => $new_rule) {
-                    $this->addRule( $new_rule, $operation );
+                    $this->addRule($new_rule, $operation);
                 }
             }
             else {
@@ -211,7 +211,7 @@ 
                     $fake_root
                 );
 
-                $this->addRule( $fake_root->getOperands()[0], $operation );
+                $this->addRule($fake_root->getOperands()[0], $operation);
             }
         }
         else {
@@ -232,10 +232,10 @@ 
      *
      * @return $this
      */
-    protected function addRule( AbstractRule $rule, $operation=AndRule::operator )
+    protected function addRule(AbstractRule $rule, $operation = AndRule::operator)
     {
-        if ( $this->rules && in_array( get_class($this->rules), [AndRule::class, OrRule::class] )
-            && ! $this->rules->getOperands() ) {
+        if ($this->rules && in_array(get_class($this->rules), [AndRule::class, OrRule::class])
+            && ! $this->rules->getOperands()) {
             throw new \LogicException(
                  "You are trying to add rules to a LogicalFilter which had "
                 ."only contradictory rules that have already been simplified: "
@@ -284,7 +284,7 @@ 
         array $rules_composition,
         AbstractOperationRule $recursion_position
     ) {
-        if ( ! array_filter($rules_composition, function ($rule_composition_part) {
+        if ( ! array_filter($rules_composition, function($rule_composition_part) {
             return is_string($rule_composition_part);
         })) {
             // at least one operator is required for operation rules
@@ -293,13 +293,13 @@ 
                 .var_export($rules_composition, true)
             );
         }
-        elseif ( 3 == count($rules_composition)
-            && ! in_array( AndRule::operator, $rules_composition, true )
-            && ! in_array( OrRule::operator,  $rules_composition, true )
-            && ! in_array( NotRule::operator, $rules_composition, true )
-            && ! in_array( AbstractRule::findSymbolicOperator( AndRule::operator ), $rules_composition, true )
-            && ! in_array( AbstractRule::findSymbolicOperator( OrRule::operator ),  $rules_composition, true )
-            && ! in_array( AbstractRule::findSymbolicOperator( NotRule::operator ), $rules_composition, true )
+        elseif (3 == count($rules_composition)
+            && ! in_array(AndRule::operator, $rules_composition, true)
+            && ! in_array(OrRule::operator, $rules_composition, true)
+            && ! in_array(NotRule::operator, $rules_composition, true)
+            && ! in_array(AbstractRule::findSymbolicOperator(AndRule::operator), $rules_composition, true)
+            && ! in_array(AbstractRule::findSymbolicOperator(OrRule::operator), $rules_composition, true)
+            && ! in_array(AbstractRule::findSymbolicOperator(NotRule::operator), $rules_composition, true)
         ) {
             // atomic or composit rules
             $operand_left  = $rules_composition[0];
@@ -309,20 +309,20 @@ 
             $rule = AbstractRule::generateSimpleRule(
                 $operand_left, $operation, $operand_right, $this->getOptions()
             );
-            $recursion_position->addOperand( $rule );
+            $recursion_position->addOperand($rule);
         }
         else {
             // operations
-            if (   NotRule::operator == $rules_composition[0]
-                || $rules_composition[0] == AbstractRule::findSymbolicOperator( NotRule::operator ) ) {
+            if (NotRule::operator == $rules_composition[0]
+                || $rules_composition[0] == AbstractRule::findSymbolicOperator(NotRule::operator)) {
                 $rule = new NotRule();
             }
-            elseif (in_array( AndRule::operator, $rules_composition )
-                || in_array( AbstractRule::findSymbolicOperator( AndRule::operator ), $rules_composition )) {
+            elseif (in_array(AndRule::operator, $rules_composition)
+                || in_array(AbstractRule::findSymbolicOperator(AndRule::operator), $rules_composition)) {
                 $rule = new AndRule();
             }
-            elseif (in_array( OrRule::operator, $rules_composition )
-                || in_array( AbstractRule::findSymbolicOperator( OrRule::operator ), $rules_composition ) ) {
+            elseif (in_array(OrRule::operator, $rules_composition)
+                || in_array(AbstractRule::findSymbolicOperator(OrRule::operator), $rules_composition)) {
                 $rule = new OrRule();
             }
             else {
@@ -336,8 +336,8 @@ 
 
             $operands_descriptions = array_filter(
                 $rules_composition,
-                function ($operand) use ($operator) {
-                    return ! in_array($operand, [$operator, AbstractRule::findSymbolicOperator( $operator )]);
+                function($operand) use ($operator) {
+                    return ! in_array($operand, [$operator, AbstractRule::findSymbolicOperator($operator)]);
                 }
             );
 
@@ -352,7 +352,7 @@ 
 
             foreach ($operands_descriptions as $i => $operands_description) {
                 if (false === $operands_description) {
-                    $operands_descriptions[ $i ] = ['and']; // FalseRule hack
+                    $operands_descriptions[$i] = ['and']; // FalseRule hack
                 }
                 elseif (null === $operands_description || true === $operands_description) {
                     $operands_description = ['and'];
@@ -363,7 +363,7 @@ 
                         );
                     }
 
-                    unset($operands_descriptions[ $i ]);
+                    unset($operands_descriptions[$i]);
                 }
             }
 
@@ -381,7 +381,7 @@ 
                 throw new \InvalidArgumentException(
                     "Mixing different operations in the same rule level not implemented: \n["
                     . implode(', ', $remaining_operations)."]\n"
-                    . 'in ' . var_export($rules_composition, true)
+                    . 'in '.var_export($rules_composition, true)
                 );
             }
 
@@ -407,7 +407,7 @@ 
                 }
             }
 
-            $recursion_position->addOperand( $rule );
+            $recursion_position->addOperand($rule);
         }
 
         return $this;
@@ -436,7 +436,7 @@ 
      */
     public function and_()
     {
-        $this->addRules( AndRule::operator, func_get_args());
+        $this->addRules(AndRule::operator, func_get_args());
         return $this;
     }
 
@@ -464,7 +464,7 @@ 
      */
     public function or_()
     {
-        $this->addRules( OrRule::operator, func_get_args());
+        $this->addRules(OrRule::operator, func_get_args());
         return $this;
     }
 
@@ -511,12 +511,12 @@ 
      * @param  array $options stop_after | stop_before |
      * @return $this
      */
-    public function simplify($options=[])
+    public function simplify($options = [])
     {
         if ($this->rules) {
             // AndRule added to make all Operation methods available
             $this->rules = (new AndRule([$this->rules]))
-                ->simplify( $options )
+                ->simplify($options)
                 // ->dump(true, false)
                 ;
         }
@@ -537,7 +537,7 @@ 
      *
      * @return bool
      */
-    public function hasSolution($save_simplification=true)
+    public function hasSolution($save_simplification = true)
     {
         if ( ! $this->rules) {
             return true;
@@ -558,7 +558,7 @@ 
      *
      * @return array A description of the rules.
      */
-    public function toArray(array $options=[])
+    public function toArray(array $options = [])
     {
         return $this->rules ? $this->rules->toArray($options) : $this->rules;
     }
@@ -570,7 +570,7 @@ 
      *
      * @return array A description of the rules.
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         return $this->rules ? $this->rules->toString($options) : $this->rules;
     }
@@ -608,7 +608,7 @@ 
      * @param  mixed $row
      * @return bool
      */
-    public function __invoke($row, $key=null)
+    public function __invoke($row, $key = null)
     {
         return $this->validates($row, $key);
     }
@@ -658,8 +658,8 @@ 
             [
                 Filterer::on_row_matches => function($rule, $key, &$rows, $matching_case) use (&$cache_flush_required) {
                     // $rule->dump();
-                    unset( $rows[$key] );
-                    if ( ! $rows ) {
+                    unset($rows[$key]);
+                    if ( ! $rows) {
                         throw new \Exception(
                              "Removing the only rule $rule from the filter $this "
                             ."produces a case which has no possible solution due to missing "
@@ -695,7 +695,7 @@ 
      *
      * @todo Merge with rules
      */
-    public function keepLeafRulesMatching($filter=[], array $options=[])
+    public function keepLeafRulesMatching($filter = [], array $options = [])
     {
         $clean_empty_branches = ! isset($options['clean_empty_branches']) || $options['clean_empty_branches'];
 
@@ -703,7 +703,7 @@ 
         // ->dump()
         ;
 
-        $options[ Filterer::leaves_only ] = true;
+        $options[Filterer::leaves_only] = true;
 
         $this->rules = (new RuleFilterer)->apply($filter, $this->rules, $options);
         // $this->rules->dump(true);
@@ -718,7 +718,7 @@ 
                 $this->rules,
                 [
                     Filterer::on_row_matches => function($rule, $key, &$rows) {
-                        unset( $rows[$key] );
+                        unset($rows[$key]);
                     },
                     Filterer::on_row_mismatches => function($rule, $key, &$rows) {
                     },
@@ -743,7 +743,7 @@ 
      *
      * @todo Merge with rules
      */
-    public function listLeafRulesMatching($filter=[])
+    public function listLeafRulesMatching($filter = [])
     {
         $filter = (new LogicalFilter($filter, new RuleFilterer))
         // ->dump()
@@ -763,7 +763,7 @@ 
                     $key,
                     array $siblings
                 ) use (&$out) {
-                    if (   ! $matching_rule instanceof AndRule
+                    if ( ! $matching_rule instanceof AndRule
                         && ! $matching_rule instanceof OrRule
                         && ! $matching_rule instanceof NotRule
                     ) {
@@ -786,7 +786,7 @@ 
      *
      * @todo Make it available on AbstractRule also
      */
-    public function onEachRule($filter=[], $options)
+    public function onEachRule($filter = [], $options)
     {
         $filter = (new LogicalFilter($filter, new RuleFilterer))
         // ->dump()
@@ -862,7 +862,7 @@ 
      *
      * @return LogicalFilter
      */
-    public function saveAs( &$variable )
+    public function saveAs(&$variable)
     {
         return $variable = $this;
     }
@@ -873,7 +873,7 @@ 
      *
      * @return LogicalFilter
      */
-    public function saveCopyAs( &$copied_variable )
+    public function saveCopyAs(&$copied_variable)
     {
         $copied_variable = $this->copy();
         return $this;
@@ -886,15 +886,15 @@ 
      *
      * @return $this
      */
-    public function dump($exit=false, array $options=[])
+    public function dump($exit = false, array $options = [])
     {
         $default_options = [
             'callstack_depth' => 3,
             'mode'            => 'string',
         ];
         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;
             }
         }
         extract($options);
@@ -905,23 +905,23 @@ 
         else {
             // TODO dump a TrueRule
             $bt     = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, $callstack_depth);
-            $caller = $bt[ $callstack_depth - 2 ];
+            $caller = $bt[$callstack_depth - 2];
 
             // get line and file from the previous level of the caller
             // TODO go deeper if this case exist?
             if ( ! isset($caller['file'])) {
-                $caller['file'] = $bt[ $callstack_depth - 3 ]['file'];
+                $caller['file'] = $bt[$callstack_depth - 3]['file'];
             }
             if ( ! isset($caller['line'])) {
-                $caller['line'] = $bt[ $callstack_depth - 3 ]['line'];
+                $caller['line'] = $bt[$callstack_depth - 3]['line'];
             }
 
             try {
-                echo "\n" . $caller['file'] . ':' . $caller['line'] . "\n";
+                echo "\n".$caller['file'].':'.$caller['line']."\n";
                 var_export($this->toArray($options));
             }
             catch (\Exception $e) {
-                echo "\nError while dumping: " . $e->getMessage() . "\n";
+                echo "\nError while dumping: ".$e->getMessage()."\n";
                 var_export($caller);
                 echo "\n\n";
                 var_export($bt);
@@ -946,7 +946,7 @@ 
      *
      * @return mixed The filtered data
      */
-    public function applyOn($data_to_filter, $action_on_matches=null, $filterer=null)
+    public function applyOn($data_to_filter, $action_on_matches = null, $filterer = null)
     {
         if ( ! $filterer) {
             $filterer = $this->getDefaultFilterer();
@@ -962,11 +962,11 @@ 
         }
 
         if ($data_to_filter instanceof LogicalFilter) {
-            $filtered_rules = $filterer->apply( $this, $data_to_filter->getRules() );
-            return $data_to_filter->flushRules()->addRule( $filtered_rules );
+            $filtered_rules = $filterer->apply($this, $data_to_filter->getRules());
+            return $data_to_filter->flushRules()->addRule($filtered_rules);
         }
         else {
-            return $filterer->apply( $this, $data_to_filter );
+            return $filterer->apply($this, $data_to_filter);
         }
     }
 
@@ -981,7 +981,7 @@ 
      *                                 + Null if the target has no sens (operation filtered by field for example)
      *                                 + A rule tree containing the first matching case if there is one.
      */
-    public function validates($value_to_check, $key_to_check=null, $filterer=null)
+    public function validates($value_to_check, $key_to_check = null, $filterer = null)
     {
         if ( ! $filterer) {
             $filterer = $this->getDefaultFilterer();
@@ -996,7 +996,7 @@ 
             );
         }
 
-        return $filterer->hasMatchingCase( $this, $value_to_check, $key_to_check );
+        return $filterer->hasMatchingCase($this, $value_to_check, $key_to_check);
     }
 
     /**/

src/Rule/AbstractAtomicRule.php

Spacing +4 added lines, -4 removed lines

@@ -21,14 +21,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;
             }
         }
 
@@ -54,7 +54,7 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         if ( ! empty($this->cache['string'])) {
             return $this->cache['string'];

src/Rule/AbstractOperationRule.php

Spacing +42 added lines, -42 removed lines

@@ -20,7 +20,7 @@ 
     const remove_negations        = 'remove_negations';
     const rootify_disjunctions    = 'rootify_disjunctions';
     const unify_atomic_operands   = 'unify_atomic_operands';
-    const remove_invalid_branches = 'remove_invalid_branches';    // simplified after this step
+    const remove_invalid_branches = 'remove_invalid_branches'; // simplified after this step
 
     const simplified              = self::remove_invalid_branches;
 
@@ -43,9 +43,9 @@ 
 
     /**
      */
-    public function __construct( array $operands=[] )
+    public function __construct(array $operands = [])
     {
-        $this->setOperands( $operands );
+        $this->setOperands($operands);
         $this->flushCache();
     }
 
@@ -64,10 +64,10 @@ 
      *
      * @return $this
      */
-    public function addOperand( AbstractRule $new_operand )
+    public function addOperand(AbstractRule $new_operand)
     {
-        if ( ! isset($this->operands[ $id = $new_operand->getSemanticId() ])) {
-            $this->operands[ $id ] = $new_operand;
+        if ( ! isset($this->operands[$id = $new_operand->getSemanticId()])) {
+            $this->operands[$id] = $new_operand;
 
             if ($this->current_simplification_step) {
                 $this->current_simplification_step = null;
@@ -84,7 +84,7 @@ 
      */
     public function getOperands()
     {
-        return array_values( $this->operands );
+        return array_values($this->operands);
     }
 
     /**
@@ -128,7 +128,7 @@ 
      * @param array  $simplification_options
      * @param bool   $force
      */
-    public function moveSimplificationStepForward($step_to_go_to, array $simplification_options, $force=false)
+    public function moveSimplificationStepForward($step_to_go_to, array $simplification_options, $force = false)
     {
         if ( ! in_array($step_to_go_to, self::simplification_steps)) {
             throw new \InvalidArgumentException(
@@ -140,18 +140,18 @@ 
         if ( ! $force && null !== $this->current_simplification_step) {
             $steps_indices = array_flip(self::simplification_steps);
 
-            $current_index = $steps_indices[ $this->current_simplification_step ];
-            $target_index  = $steps_indices[ $step_to_go_to ];
+            $current_index = $steps_indices[$this->current_simplification_step];
+            $target_index  = $steps_indices[$step_to_go_to];
 
-            if ( $current_index >= $target_index ) {
+            if ($current_index >= $target_index) {
                 // allow recall of previous step without going back
                 return;
             }
-            elseif ( $current_index < $target_index - 1 ) {
+            elseif ($current_index < $target_index - 1) {
                 throw new \LogicException(
-                    "$step_to_go_to MUST be fullfilled after " . self::simplification_steps[$target_index - 1]
-                    . " instead of the current step: " . $this->current_simplification_step
-                    ."\nfor: " . $this
+                    "$step_to_go_to MUST be fullfilled after ".self::simplification_steps[$target_index - 1]
+                    . " instead of the current step: ".$this->current_simplification_step
+                    ."\nfor: ".$this
                 );
             }
         }
@@ -180,8 +180,8 @@ 
 
         $steps_indices = array_flip(self::simplification_steps);
 
-        $current_index = $steps_indices[ $this->current_simplification_step ];
-        $step_index    = $steps_indices[ $step ];
+        $current_index = $steps_indices[$this->current_simplification_step];
+        $step_index    = $steps_indices[$step];
 
         return $current_index >= $step_index;
     }
@@ -207,7 +207,7 @@ 
                 }
 
                 if ($operands[$i] instanceof AbstractOperationRule) {
-                    $operands[$i]->removeNegations( $contextual_options );
+                    $operands[$i]->removeNegations($contextual_options);
                 }
             }
 
@@ -230,11 +230,11 @@ 
      *
      * @return AbstractOperationRule
      */
-    public function cleanOperations(array $simplification_options, $recurse=true)
+    public function cleanOperations(array $simplification_options, $recurse = true)
     {
         if ($recurse) {
             foreach ($this->operands as $i => $operand) {
-                if (     $operand instanceof AbstractOperationRule
+                if ($operand instanceof AbstractOperationRule
                     && ! $operand instanceof InRule
                     && ! $operand instanceof NotEqualRule
                     && ! $operand instanceof NotInRule
@@ -307,7 +307,7 @@ 
     public function unifyAtomicOperands($simplification_strategy_step = false, array $contextual_options)
     {
         if ($simplification_strategy_step) {
-            $this->moveSimplificationStepForward( self::unify_atomic_operands, $contextual_options );
+            $this->moveSimplificationStepForward(self::unify_atomic_operands, $contextual_options);
         }
 
         // $this->dump(true);
@@ -343,7 +343,7 @@ 
                 catch (\Exception $e) {
                     VisibilityViolator::setHiddenProperty(
                         $e, 'message',
-                        $e->getMessage() . "\n" . var_export($operandsByOperator, true)
+                        $e->getMessage()."\n".var_export($operandsByOperator, true)
                     );
 
                     throw $e;
@@ -351,7 +351,7 @@ 
             }
         }
 
-        return $this->setOperandsOrReplaceByOperation( $unifiedOperands, $contextual_options );
+        return $this->setOperandsOrReplaceByOperation($unifiedOperands, $contextual_options);
     }
 
     private static $simplification_cache = [];
@@ -367,10 +367,10 @@ 
      *
      * @return AbstractRule the simplified rule
      */
-    final public function simplify($options=[])
+    final public function simplify($options = [])
     {
-        $step_to_stop_before = ! empty($options['stop_before'])        ? $options['stop_before'] : null;
-        $step_to_stop_after  = ! empty($options['stop_after'])         ? $options['stop_after']  : null;
+        $step_to_stop_before = ! empty($options['stop_before']) ? $options['stop_before'] : null;
+        $step_to_stop_after  = ! empty($options['stop_after']) ? $options['stop_after'] : null;
         $force_logical_core  = ! empty($options['force_logical_core']) ? $options['force_logical_core'] : false;
 
         if ($step_to_stop_before && ! in_array($step_to_stop_before, self::simplification_steps)) {
@@ -408,7 +408,7 @@ 
         // $instance->dump(true);
 
         if (self::remove_negations == $step_to_stop_after ||
-            self::rootify_disjunctions == $step_to_stop_before ) {
+            self::rootify_disjunctions == $step_to_stop_before) {
             return $instance;
         }
 
@@ -420,7 +420,7 @@ 
         // $instance->dump(true);
 
         if (self::rootify_disjunctions == $step_to_stop_after ||
-            self::unify_atomic_operands == $step_to_stop_before ) {
+            self::unify_atomic_operands == $step_to_stop_before) {
             return $instance;
         }
 
@@ -431,7 +431,7 @@ 
             // $instance->dump(true);
 
             if (self::unify_atomic_operands == $step_to_stop_after ||
-                self::remove_invalid_branches == $step_to_stop_before ) {
+                self::remove_invalid_branches == $step_to_stop_before) {
                 return $instance;
             }
 
@@ -448,7 +448,7 @@ 
         // last non recursive clean
         // TODO kind of monad|become|cese
         //@see https://github.com/jclaveau/php-logical-filter/issues/20
-        if ($instance instanceof AndRule || $instance instanceof OrRule ) {
+        if ($instance instanceof AndRule || $instance instanceof OrRule) {
             if ( ! $instance->getOperands()) {
                 return $instance;
             }
@@ -487,7 +487,7 @@ 
 
         $cache_keys[] = $instance->getSemanticId().'-'.$options_id;
         foreach ($cache_keys as $cache_key) {
-            self::$simplification_cache[ $cache_key ] = $instance;
+            self::$simplification_cache[$cache_key] = $instance;
         }
 
         return $instance->copy();
@@ -510,15 +510,15 @@ 
             // For FilteredValue and FilteredKey
             $field = (string) $field;
 
-            if ( ! isset($operandsByFields[ $field ])) {
-                $operandsByFields[ $field ] = [];
+            if ( ! isset($operandsByFields[$field])) {
+                $operandsByFields[$field] = [];
             }
 
-            if ( ! isset($operandsByFields[ $field ][ $operand::operator ])) {
-                $operandsByFields[ $field ][ $operand::operator ] = [];
+            if ( ! isset($operandsByFields[$field][$operand::operator])) {
+                $operandsByFields[$field][$operand::operator] = [];
             }
 
-            $operandsByFields[ $field ][ $operand::operator ][] = $operand;
+            $operandsByFields[$field][$operand::operator][] = $operand;
         }
 
         return $operandsByFields;
@@ -541,15 +541,15 @@ 
             // For FilteredValue and FilteredKey
             $field = (string) $field;
 
-            if ( ! isset($operandsByFields[ $field ])) {
-                $operandsByFields[ $field ] = [];
+            if ( ! isset($operandsByFields[$field])) {
+                $operandsByFields[$field] = [];
             }
 
-            if ( ! isset($operandsByFields[ $field ][ $operand::operator ])) {
-                $operandsByFields[ $field ][ $operand::operator ] = [];
+            if ( ! isset($operandsByFields[$field][$operand::operator])) {
+                $operandsByFields[$field][$operand::operator] = [];
             }
 
-            $operandsByFields[ $field ][ $operand::operator ][] = $operand;
+            $operandsByFields[$field][$operand::operator][] = $operand;
         }
 
         return $operandsByFields;
@@ -587,7 +587,7 @@ 
      *
      * @return AbstractRule|null The operand if it exists or null
      */
-    protected function getOperandAt($index=0)
+    protected function getOperandAt($index = 0)
     {
         $operands = array_values($this->operands);
         if (isset($operands[$index])) {

src/Rule/AndRule.php

Spacing +137 added lines, -137 removed lines

@@ -57,11 +57,11 @@ 
 
         foreach ($upLiftedOperands as $i => $operand) {
             if ($operand instanceof NotRule) {
-                if (    ($operand instanceof NotEqualRule || $operand instanceof NotInRule)
+                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 {
@@ -83,9 +83,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);
                         }
                     }
                 }
@@ -102,7 +102,7 @@ 
                         );
                     }
 
-                    $upLifdtedOperand->addOperand( $operand->copy() );
+                    $upLifdtedOperand->addOperand($operand->copy());
                 }
             }
         }
@@ -117,7 +117,7 @@ 
      *
      * @todo same as OrRule
      */
-    public function toArray(array $options=[])
+    public function toArray(array $options = [])
     {
         $default_options = [
             'show_instance' => false,
@@ -125,8 +125,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;
             }
         }
 
@@ -165,7 +165,7 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         $operator = self::operator;
         if ( ! $this->operands) {
@@ -180,7 +180,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 .= ']';
@@ -204,7 +204,7 @@ 
 
             // 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]);
 
@@ -231,7 +231,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 = [];
@@ -245,8 +245,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 = [];
@@ -256,55 +256,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 = [];
@@ -324,7 +324,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(
@@ -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;
                             }
@@ -420,10 +420,10 @@ 
                                 continue;
                             }
 
-                            $first_in->setPossibilities( array_intersect(
+                            $first_in->setPossibilities(array_intersect(
                                 $first_in->getPossibilities(),
                                 $next_in->getPossibilities()
-                            ) );
+                            ));
 
                             unset($operands[$i]);
                         }
@@ -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]"
                         );
                     }
@@ -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 ( ! 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);
         }
     }