jclaveau / php-logical-filter

src/Rule/Trait_RuleWithField.php

Spacing +4 added lines, -4 removed lines

@@ -23,7 +23,7 @@ 
     /**
      * @return string $field
      */
-    final public function setField( $field )
+    final public function setField($field)
     {
         if (!is_scalar($field)) {
             throw new \InvalidArgumentEXception(
@@ -49,17 +49,17 @@ 
     final public function renameField($renamings)
     {
         if (is_callable($renamings)) {
-            $this->setField( call_user_func($renamings, $this->field) );
+            $this->setField(call_user_func($renamings, $this->field));
         }
         elseif (is_array($renamings)) {
             if (isset($renamings[$this->field])) {
-                $this->setField( $renamings[$this->field] );
+                $this->setField($renamings[$this->field]);
             }
         }
         else {
             throw new \InvalidArgumentException(
                 "\$renamings MUST be a callable or an associative array "
-                ."instead of: " . var_export($renamings, true)
+                ."instead of: ".var_export($renamings, true)
             );
         }
 

Braces +2 added lines, -4 removed lines

@@ -50,13 +50,11 @@
     {
         if (is_callable($renamings)) {
             $this->setField( call_user_func($renamings, $this->field) );
-        }
-        elseif (is_array($renamings)) {
+        } elseif (is_array($renamings)) {
             if (isset($renamings[$this->field])) {
                 $this->setField( $renamings[$this->field] );
             }
-        }
-        else {
+        } else {
             throw new \InvalidArgumentException(
                 "\$renamings MUST be a callable or an associative array "
                 ."instead of: " . var_export($renamings, true)

src/Rule/AbstractRule.php

Spacing +20 added lines, -20 removed lines

@@ -33,9 +33,9 @@ 
      */
     public static function findSymbolicOperator($english_operator)
     {
-        $association = array_flip( self::$ruleAliases );
-        if (isset($association[ $english_operator ])) {
-            return $association[ $english_operator ];
+        $association = array_flip(self::$ruleAliases);
+        if (isset($association[$english_operator])) {
+            return $association[$english_operator];
         }
 
         return $english_operator;
@@ -46,8 +46,8 @@ 
     public static function findEnglishOperator($symbolic_operator)
     {
         $association = self::$ruleAliases;
-        if (isset($association[ $symbolic_operator ])) {
-            return $association[ $symbolic_operator ];
+        if (isset($association[$symbolic_operator])) {
+            return $association[$symbolic_operator];
         }
 
         return $symbolic_operator;
@@ -65,16 +65,16 @@ 
      *
      * @return $this
      */
-    public static function generateSimpleRule($field, $type, $values, array $options=[])
+    public static function generateSimpleRule($field, $type, $values, array $options = [])
     {
-        $cache_key = hash('md4', serialize( func_get_args()) );
+        $cache_key = hash('md4', serialize(func_get_args()));
         if (isset(self::$static_cache['rules_generation'][$cache_key])) {
             return self::$static_cache['rules_generation'][$cache_key]->copy();
         }
 
         $ruleClass = self::getRuleClass($type);
 
-        return self::$static_cache['rules_generation'][$cache_key] = new $ruleClass( $field, $values, $options );
+        return self::$static_cache['rules_generation'][$cache_key] = new $ruleClass($field, $values, $options);
     }
 
     /**
@@ -91,7 +91,7 @@ 
             . str_replace('_', '', ucwords($english_rule_operator, '_'))
             . 'Rule';
 
-        if (!class_exists( $rule_class)) {
+        if (!class_exists($rule_class)) {
             throw new \InvalidArgumentException(
                 "The class '$rule_class' corresponding to the  operator "
                 ."'$rule_operator' / '$english_rule_operator' cannot be found."
@@ -120,7 +120,7 @@ 
      *
      * @return $this
      */
-    final public function dump($exit=false, array $options=[])
+    final public function dump($exit = false, array $options = [])
     {
         $default_options = [
             'callstack_depth' => 2,
@@ -128,18 +128,18 @@ 
             // '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;
             }
         }
         extract($options);
 
         $bt = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, $callstack_depth);
-        $caller = $bt[ $callstack_depth - 2 ];
+        $caller = $bt[$callstack_depth - 2];
 
-        echo "\n" . $caller['file'] . ':' . $caller['line'] . "\n";
+        echo "\n".$caller['file'].':'.$caller['line']."\n";
         if ($mode == 'string') {
-            if ( ! isset($options['indent_unit'])) {
+            if (!isset($options['indent_unit'])) {
                 $options['indent_unit'] = "    ";
             }
 
@@ -157,10 +157,10 @@ 
             }
         }
         elseif ($mode == 'xdebug') {
-            if ( ! function_exists('xdebug_is_enabled')) {
+            if (!function_exists('xdebug_is_enabled')) {
                 throw new \RuntimeException("Xdebug is not installed");
             }
-            if ( ! xdebug_is_enabled()) {
+            if (!xdebug_is_enabled()) {
                 throw new \RuntimeException("Xdebug is disabled");
             }
 
@@ -180,7 +180,7 @@ 
         else {
             throw new \InvalidArgumentException(
                  "'mode' option must belong to ['string', 'export', 'dump'] "
-                ."instead of " . var_export($mode, true)
+                ."instead of ".var_export($mode, true)
             );
         }
         echo "\n\n";
@@ -262,9 +262,9 @@ 
         }
 
         // return hash('crc32b', serialize( $this->toArray() ));
-        return hash('md4', serialize( $this->toArray(['semantic' => true]) ))  // faster but longer
+        return hash('md4', serialize($this->toArray(['semantic' => true])))  // faster but longer
               .'-'
-              .hash('md4', serialize( $this->options ))
+              .hash('md4', serialize($this->options))
               ;
     }
 

Braces +7 added lines, -14 removed lines

@@ -144,8 +144,7 @@ 
             }
 
             echo ($this->toString($options));
-        }
-        elseif ($mode == 'dump') {
+        } elseif ($mode == 'dump') {
             if ($xdebug_enabled = ini_get('xdebug.overload_var_dump')) {
                 ini_set('xdebug.overload_var_dump', 0);
             }
@@ -155,8 +154,7 @@ 
             if ($xdebug_enabled) {
                 ini_set('xdebug.overload_var_dump', 1);
             }
-        }
-        elseif ($mode == 'xdebug') {
+        } elseif ($mode == 'xdebug') {
             if ( ! function_exists('xdebug_is_enabled')) {
                 throw new \RuntimeException("Xdebug is not installed");
             }
@@ -173,11 +171,9 @@ 
             if ($xdebug_enabled) {
                 ini_set('xdebug.overload_var_dump', 0);
             }
-        }
-        elseif ($mode == 'export') {
+        } elseif ($mode == 'export') {
             var_export($this->toArray($options));
-        }
-        else {
+        } else {
             throw new \InvalidArgumentException(
                  "'mode' option must belong to ['string', 'export', 'dump'] "
                 ."instead of " . var_export($mode, true)
@@ -288,21 +284,18 @@ 
                     $this
                 ])
             ]);
-        }
-        elseif ($this instanceof AndRule) {
+        } elseif ($this instanceof AndRule) {
             $ruleTree = new OrRule([
                 $this
             ]);
-        }
-        elseif ($this instanceof OrRule) {
+        } elseif ($this instanceof OrRule) {
             foreach ($this->operands as $i => $operand) {
                 if (!$operand instanceof AndRule) {
                     $this->operands[$i] = new AndRule([$operand]);
                 }
             }
             $ruleTree = $this;
-        }
-        else {
+        } else {
             throw new \LogicException(
                 "Unhandled type of simplified rules provided for conversion: "
                 .$this

src/Rule/NotEqualRule.php

Spacing +7 added lines, -7 removed lines

@@ -18,7 +18,7 @@ 
      * @param string $field The field to apply the rule on.
      * @param array  $value The value the field can equal to.
      */
-    public function __construct( $field, $value, array $options=[] )
+    public function __construct($field, $value, array $options = [])
     {
         $this->field = $field;
         $this->value = $value;
@@ -29,7 +29,7 @@ 
 
     /**
      */
-    public function isNormalizationAllowed(array $contextual_options=[])
+    public function isNormalizationAllowed(array $contextual_options = [])
     {
         $operand = $this->getOperandAt(0);
 
@@ -58,14 +58,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;
             }
         }
 
@@ -89,7 +89,7 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         if (!empty($this->cache['string'])) {
             return $this->cache['string'];
@@ -108,7 +108,7 @@ 
      *
      * @return bool
      */
-    public function hasSolution(array $simplification_options=[])
+    public function hasSolution(array $simplification_options = [])
     {
         return true;
     }

Braces +1 added lines, -2 removed lines

@@ -81,8 +81,7 @@
 
         if (!$options['show_instance']) {
             return $this->cache['array'] = $array;
-        }
-        else {
+        } else {
             return $array;
         }
     }

src/Rule/AbstractOperationRule.php

Spacing +45 added lines, -45 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 && $this->current_simplification_step !== null) {
             $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);
                 }
             }
 
@@ -227,11 +227,11 @@ 
      *
      * @return $this;
      */
-    public function cleanOperations($simplification_options, $recurse=true)
+    public function cleanOperations($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
@@ -305,7 +305,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);
@@ -341,7 +341,7 @@ 
                 catch (\Exception $e) {
                     VisibilityViolator::setHiddenProperty(
                         $e, 'message',
-                        $e->getMessage() . "\n" . var_export($operandsByOperator, true)
+                        $e->getMessage()."\n".var_export($operandsByOperator, true)
                     );
 
                     throw $e;
@@ -349,7 +349,7 @@ 
             }
         }
 
-        return $this->setOperandsOrReplaceByOperation( $unifiedOperands, $contextual_options );
+        return $this->setOperandsOrReplaceByOperation($unifiedOperands, $contextual_options);
     }
 
     private static $simplification_cache = [];
@@ -365,10 +365,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)) {
@@ -405,8 +405,8 @@ 
 
         // $instance->dump(true);
 
-        if ($step_to_stop_after  == self::remove_negations ||
-            $step_to_stop_before == self::rootify_disjunctions ) {
+        if ($step_to_stop_after == self::remove_negations ||
+            $step_to_stop_before == self::rootify_disjunctions) {
             return $instance;
         }
 
@@ -417,8 +417,8 @@ 
 
         // $instance->dump(true);
 
-        if ($step_to_stop_after  == self::rootify_disjunctions ||
-            $step_to_stop_before == self::unify_atomic_operands ) {
+        if ($step_to_stop_after == self::rootify_disjunctions ||
+            $step_to_stop_before == self::unify_atomic_operands) {
             return $instance;
         }
 
@@ -428,8 +428,8 @@ 
 
             // $instance->dump(true);
 
-            if ($step_to_stop_after  == self::unify_atomic_operands ||
-                $step_to_stop_before == self::remove_invalid_branches ) {
+            if ($step_to_stop_after == self::unify_atomic_operands ||
+                $step_to_stop_before == self::remove_invalid_branches) {
                 return $instance;
             }
 
@@ -446,7 +446,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;
             }
@@ -486,7 +486,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();
@@ -509,15 +509,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;
@@ -540,15 +540,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;
@@ -586,7 +586,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])) {

Braces +4 added lines, -8 removed lines

@@ -111,8 +111,7 @@ 
         foreach ($this->operands as $operand) {
             if (method_exists($operand, 'renameField')) {
                 $operand->renameField($renamings);
-            }
-            else {
+            } else {
                 $operand->renameFields($renamings);
             }
         }
@@ -146,8 +145,7 @@ 
             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
@@ -279,8 +277,7 @@ 
 
             if ($operand instanceof InRule && !$operand->isNormalizationAllowed($simplification_options)) {
                 $count = count($operand->getPossibilities());
-            }
-            else {
+            } else {
                 $count = count($operand->getOperands());
             }
 
@@ -337,8 +334,7 @@ 
             foreach ($operandsByOperator as $operator => $operands) {
                 try {
                     $unifiedOperands = array_merge($unifiedOperands, $operands);
-                }
-                catch (\Exception $e) {
+                } catch (\Exception $e) {
                     VisibilityViolator::setHiddenProperty(
                         $e, 'message',
                         $e->getMessage() . "\n" . var_export($operandsByOperator, true)

src/Rule/BelowRule.php

Spacing +6 added lines, -6 removed lines

@@ -16,9 +16,9 @@ 
      * @param string $field The field to apply the rule on.
      * @param array  $value The value the field can below to.
      */
-    public function __construct( $field, $maximum )
+    public function __construct($field, $maximum)
     {
-        if (    !is_scalar($maximum)
+        if (!is_scalar($maximum)
             &&  !$maximum instanceof \DateTimeInterface
             &&  null !== $maximum
         ) {
@@ -38,15 +38,15 @@ 
      *
      * @return bool
      */
-    public function hasSolution(array $contextual_options=[])
+    public function hasSolution(array $contextual_options = [])
     {
         // if minimum is null, the rule is equivalent to true
-        if (is_numeric( $this->maximum )) {
-            if (is_nan( $this->maximum )) {
+        if (is_numeric($this->maximum)) {
+            if (is_nan($this->maximum)) {
                 return false;
             }
 
-            if (is_infinite( $this->maximum ) && $this->maximum < 0) {
+            if (is_infinite($this->maximum) && $this->maximum < 0) {
                 return false;
             }
         }

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

Braces +3 added lines, -6 removed lines

@@ -47,8 +47,7 @@ 
 
         if (!$options['show_instance']) {
             return $this->cache['array'] = $array;
-        }
-        else {
+        } else {
             return $array;
         }
     }
@@ -70,11 +69,9 @@ 
 
         if ($field instanceof FilteredValue || $field instanceof FilteredKey) {
             $field = "$field";
-        }
-        elseif ($field instanceof \Closure) {
+        } elseif ($field instanceof \Closure) {
             throw new \Exception("Closures dump not implemented");
-        }
-        else {
+        } else {
             $field = "'$field'";
         }
 

src/Rule/AndRule.php

Spacing +142 added lines, -142 removed lines

@@ -25,7 +25,7 @@ 
             return $this;
         }
 
-        $this->moveSimplificationStepForward( self::rootify_disjunctions, $simplification_options );
+        $this->moveSimplificationStepForward(self::rootify_disjunctions, $simplification_options);
 
         $upLiftedOperands = [];
         foreach ($this->getOperands() as $operand) {
@@ -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);
                         }
                     }
                 }
@@ -101,7 +101,7 @@ 
                         );
                     }
 
-                    $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,8 +124,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;
             }
         }
 
@@ -164,7 +164,7 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         $operator = self::operator;
         if (!$this->operands) {
@@ -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]);
 
@@ -230,7 +230,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 = [];
@@ -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])
                     && $equalRule->getValue() === null
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   !empty($operandsByOperator[ BelowRule::operator ])
-                    && $equalRule->getValue() >= reset($operandsByOperator[ BelowRule::operator ])->getMaximum()
+                if (!empty($operandsByOperator[BelowRule::operator])
+                    && $equalRule->getValue() >= reset($operandsByOperator[BelowRule::operator])->getMaximum()
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   !empty($operandsByOperator[ AboveRule::operator ])
+                if (!empty($operandsByOperator[AboveRule::operator])
                     && $equalRule->getValue() === null
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   !empty($operandsByOperator[ AboveRule::operator ])
-                    && $equalRule->getValue() <= reset($operandsByOperator[ AboveRule::operator ])->getMinimum()
+                if (!empty($operandsByOperator[AboveRule::operator])
+                    && $equalRule->getValue() <= reset($operandsByOperator[AboveRule::operator])->getMinimum()
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   !empty($operandsByOperator[ NotEqualRule::operator ])
-                    && $equalRule->getValue() == reset($operandsByOperator[ NotEqualRule::operator ])->getValue()
+                if (!empty($operandsByOperator[NotEqualRule::operator])
+                    && $equalRule->getValue() == reset($operandsByOperator[NotEqualRule::operator])->getValue()
                 ) {
                     $this->operands = [];
                     return $this;
                 }
 
-                if (   !empty($operandsByOperator[ NotEqualRule::operator ])
+                if (!empty($operandsByOperator[NotEqualRule::operator])
                     && $equalRule->getValue() === null
-                    && reset($operandsByOperator[ NotEqualRule::operator ])->getValue() === null
+                    && reset($operandsByOperator[NotEqualRule::operator])->getValue() === null
                 ) {
                     $this->operands = [];
                     return $this;
                 }
             }
-            elseif (   !empty($operandsByOperator[ BelowRule::operator ])
-                    && !empty($operandsByOperator[ AboveRule::operator ])) {
-                $aboveRule = reset($operandsByOperator[ AboveRule::operator ]);
-                $belowRule = reset($operandsByOperator[ BelowRule::operator ]);
+            elseif (!empty($operandsByOperator[BelowRule::operator])
+                    && !empty($operandsByOperator[AboveRule::operator])) {
+                $aboveRule = reset($operandsByOperator[AboveRule::operator]);
+                $belowRule = reset($operandsByOperator[BelowRule::operator]);
 
                 if ($belowRule->getMaximum() <= $aboveRule->getMinimum()) {
                     $this->operands = [];
@@ -323,7 +323,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 ($operator == AboveRule::operator) {
-                        usort($operands, function( AboveRule $a, AboveRule $b ) {
+                        usort($operands, function(AboveRule $a, AboveRule $b) {
                             if ($a->getMinimum() === null) {
                                 return 1;
                             }
@@ -374,7 +374,7 @@ 
                         $operands = [reset($operands)];
                     }
                     elseif ($operator == BelowRule::operator) {
-                        usort($operands, function( BelowRule $a, BelowRule $b ) {
+                        usort($operands, function(BelowRule $a, BelowRule $b) {
                             if ($a->getMaximum() === null) {
                                 return 1;
                             }
@@ -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 (count($operandsByOperator[ $unifyable_operator ]) != 1) {
+                if (!empty($operandsByOperator[$unifyable_operator])) {
+                    if (count($operandsByOperator[$unifyable_operator]) != 1) {
                         throw new \LogicException(
-                            __METHOD__ . " MUST be called after unifyAtomicOperands() "
+                            __METHOD__." MUST be called after unifyAtomicOperands() "
                             ."to have only one '$unifyable_operator' predicate istead of:\n"
-                            ."[\n".implode( ",\n", array_map(function ($rule) {
+                            ."[\n".implode(",\n", array_map(function($rule) {
                                 return $rule->toString();
-                            }, $operandsByOperator[ $unifyable_operator ])
+                            }, $operandsByOperator[$unifyable_operator])
                             )."\n]"
                         );
                     }
@@ -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 ($equalRule->getValue() !== null) {
                         if ($not_equal_rule->getValue() === null) { // means if exists <=> equals something
-                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            unset($operandsByOperator[NotEqualRule::operator][$i]);
                         }
                         elseif ($not_equal_rule->getValue() != $equalRule->getValue()) {
-                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            unset($operandsByOperator[NotEqualRule::operator][$i]);
                         }
                     }
-                    elseif ($equalRule->getValue() === null ) {
+                    elseif ($equalRule->getValue() === null) {
                         if ($not_equal_rule->getValue() !== null) {
-                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                            unset($operandsByOperator[NotEqualRule::operator][$i]);
                         }
                         // else we let the "equal null" and the "not equal null" for the romeInvalidBranches step
                     }
                 }
             }
 
-            if (!empty($operandsByOperator[ AboveRule::operator ])) {
-                $aboveRule = reset($operandsByOperator[ AboveRule::operator ]);
+            if (!empty($operandsByOperator[AboveRule::operator])) {
+                $aboveRule = reset($operandsByOperator[AboveRule::operator]);
                 if ($equalRule->getValue() !== null && $aboveRule->getMinimum() < $equalRule->getValue()) {
-                    unset($operandsByOperator[ AboveRule::operator ]);
+                    unset($operandsByOperator[AboveRule::operator]);
                 }
             }
 
-            if (!empty($operandsByOperator[ BelowRule::operator ])) {
-                $belowRule = reset($operandsByOperator[ BelowRule::operator ]);
+            if (!empty($operandsByOperator[BelowRule::operator])) {
+                $belowRule = reset($operandsByOperator[BelowRule::operator]);
                 if ($equalRule->getValue() !== null && $belowRule->getMaximum() > $equalRule->getValue()) {
-                    unset($operandsByOperator[ BelowRule::operator ]);
+                    unset($operandsByOperator[BelowRule::operator]);
                 }
             }
 
-            if (!empty($operandsByOperator[ InRule::operator ])) {
-                $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 ($notEqualRule->getValue() === null) {
-                        if (!empty($operandsByOperator[ AboveRule::operator ])) {
-                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                        if (!empty($operandsByOperator[AboveRule::operator])) {
+                            unset($operandsByOperator[NotEqualRule::operator][$i]);
                         }
 
-                        if (!empty($operandsByOperator[ BelowRule::operator ])) {
-                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                        if (!empty($operandsByOperator[BelowRule::operator])) {
+                            unset($operandsByOperator[NotEqualRule::operator][$i]);
                         }
 
-                        if (!empty($operandsByOperator[ EqualRule::operator ])) {
-                            if (reset($operandsByOperator[ EqualRule::operator ])->getValue() !== null) {
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                        if (!empty($operandsByOperator[EqualRule::operator])) {
+                            if (reset($operandsByOperator[EqualRule::operator])->getValue() !== null) {
+                                unset($operandsByOperator[NotEqualRule::operator][$i]);
                             }
                         }
                     }
                     else {
-                        if (!empty($operandsByOperator[ AboveRule::operator ])) {
-                            if ($operandsByOperator[ AboveRule::operator ][0]->getMinimum() >= $notEqualRule->getValue()) {
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                        if (!empty($operandsByOperator[AboveRule::operator])) {
+                            if ($operandsByOperator[AboveRule::operator][0]->getMinimum() >= $notEqualRule->getValue()) {
+                                unset($operandsByOperator[NotEqualRule::operator][$i]);
                             }
                         }
 
-                        if (!empty($operandsByOperator[ BelowRule::operator ])) {
-                            if ($operandsByOperator[ BelowRule::operator ][0]->getMaximum() <= $notEqualRule->getValue()) {
-                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
+                        if (!empty($operandsByOperator[BelowRule::operator])) {
+                            if ($operandsByOperator[BelowRule::operator][0]->getMaximum() <= $notEqualRule->getValue()) {
+                                unset($operandsByOperator[NotEqualRule::operator][$i]);
                             }
                         }
                     }
 
-                    if (!empty($operandsByOperator[ NotInRule::operator ])) {
-                        $notInRule = reset($operandsByOperator[ NotInRule::operator ]);
+                    if (!empty($operandsByOperator[NotInRule::operator])) {
+                        $notInRule = reset($operandsByOperator[NotInRule::operator]);
                         if (!in_array($notEqualRule->getValue(), $notInRule->getPossibilities())) {
                             // TODO Replace it by a FalseRule
-                            $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 ])->getMaximum();
+            if (!empty($operandsByOperator[BelowRule::operator])) {
+                $upper_limit = reset($operandsByOperator[BelowRule::operator])->getMaximum();
 
-                $operandsByOperator[ InRule::operator ][0]->setPossibilities(
-                    array_filter( $inRule->getPossibilities(), function ($possibility) use ($upper_limit) {
+                $operandsByOperator[InRule::operator][0]->setPossibilities(
+                    array_filter($inRule->getPossibilities(), function($possibility) use ($upper_limit) {
                         return $possibility < $upper_limit;
                     } )
                 );
 
-                unset($operandsByOperator[ BelowRule::operator ]);
+                unset($operandsByOperator[BelowRule::operator]);
             }
 
-            if (!empty($operandsByOperator[ AboveRule::operator ])) {
-                $lower_limit = reset($operandsByOperator[ AboveRule::operator ])->getMinimum();
+            if (!empty($operandsByOperator[AboveRule::operator])) {
+                $lower_limit = reset($operandsByOperator[AboveRule::operator])->getMinimum();
 
-                $operandsByOperator[ InRule::operator ][0]->setPossibilities(
-                    array_filter( $inRule->getPossibilities(), function ($possibility) use ($lower_limit) {
+                $operandsByOperator[InRule::operator][0]->setPossibilities(
+                    array_filter($inRule->getPossibilities(), function($possibility) use ($lower_limit) {
                         return $possibility > $lower_limit;
                     } )
                 );
 
-                unset($operandsByOperator[ AboveRule::operator ]);
+                unset($operandsByOperator[AboveRule::operator]);
             }
         }
 
         // Comparison between NotInRules and > or <
-        if (!empty($operandsByOperator[ NotInRule::operator ])) {
-            $notInRule = $operandsByOperator[ NotInRule::operator ][0];
+        if (!empty($operandsByOperator[NotInRule::operator])) {
+            $notInRule = $operandsByOperator[NotInRule::operator][0];
 
-            if (!empty($operandsByOperator[ BelowRule::operator ])) {
-                $upper_limit = reset($operandsByOperator[ BelowRule::operator ])->getUpperLimit();
+            if (!empty($operandsByOperator[BelowRule::operator])) {
+                $upper_limit = reset($operandsByOperator[BelowRule::operator])->getUpperLimit();
 
-                $operandsByOperator[ NotInRule::operator ][0]->setPossibilities(
-                    array_filter( $notInRule->getPossibilities(), function ($possibility) use ($upper_limit) {
+                $operandsByOperator[NotInRule::operator][0]->setPossibilities(
+                    array_filter($notInRule->getPossibilities(), function($possibility) use ($upper_limit) {
                         return $possibility < $upper_limit;
                     } )
                 );
             }
 
-            if (!empty($operandsByOperator[ AboveRule::operator ])) {
-                $lower_limit = reset($operandsByOperator[ AboveRule::operator ])->getMinimum();
+            if (!empty($operandsByOperator[AboveRule::operator])) {
+                $lower_limit = reset($operandsByOperator[AboveRule::operator])->getMinimum();
 
-                $operandsByOperator[ NotInRule::operator ][0]->setPossibilities(
-                    array_filter( $notInRule->getPossibilities(), function ($possibility) use ($lower_limit) {
+                $operandsByOperator[NotInRule::operator][0]->setPossibilities(
+                    array_filter($notInRule->getPossibilities(), function($possibility) use ($lower_limit) {
                         return $possibility > $lower_limit;
                     } )
                 );
@@ -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);
         }
     }
 

Braces +22 added lines, -44 removed lines

@@ -62,15 +62,13 @@ 
                     foreach ($upLiftedOr->getOperands() as $upLifdtedOperand) {
                         $upLifdtedOperand->addOperand( $operand->copy() );
                     }
-                }
-                else {
+                } else {
                     throw new \LogicException(
                         "Rootifying disjunctions MUST be done after negations removal instead of '".$operand."' \n"
                         .$operand
                     );
                 }
-            }
-            elseif ($operand instanceof OrRule && $operand->isNormalizationAllowed($simplification_options)) {
+            } elseif ($operand instanceof OrRule && $operand->isNormalizationAllowed($simplification_options)) {
 
                 // If an operand is an Or, me transform the current
                 // (A' || A") && (B')       <=> (A' && B') || (A" && B');
@@ -90,8 +88,7 @@ 
                 }
 
                 $upLiftedOr = $newUpLiftedOr;
-            }
-            else {
+            } else {
                 // append the operand to all the operands of the $upLiftedOr
                 foreach ($upLiftedOr->getOperands() as $upLifdtedOperand) {
                     if (!$upLifdtedOperand instanceof AndRule) {
@@ -147,16 +144,14 @@ 
                 [self::operator],
                 $operands_semantic_ids
             );
-        }
-        else {
+        } else {
             foreach ($operands as $operand) {
                 $operands_as_array[] = $operand->toArray($options);
             }
 
             if (!$options['show_instance']) {
                 return $this->cache['array'] = $operands_as_array;
-            }
-            else {
+            } else {
                 return $operands_as_array;
             }
         }
@@ -299,8 +294,7 @@ 
                     $this->operands = [];
                     return $this;
                 }
-            }
-            elseif (   !empty($operandsByOperator[ BelowRule::operator ])
+            } elseif (   !empty($operandsByOperator[ BelowRule::operator ])
                     && !empty($operandsByOperator[ AboveRule::operator ])) {
                 $aboveRule = reset($operandsByOperator[ AboveRule::operator ]);
                 $belowRule = reset($operandsByOperator[ BelowRule::operator ]);
@@ -372,8 +366,7 @@ 
                             return 1;
                         });
                         $operands = [reset($operands)];
-                    }
-                    elseif ($operator == BelowRule::operator) {
+                    } elseif ($operator == BelowRule::operator) {
                         usort($operands, function( BelowRule $a, BelowRule $b ) {
                             if ($a->getMaximum() === null) {
                                 return 1;
@@ -390,8 +383,7 @@ 
                             return 1;
                         });
                         $operands = [reset($operands)];
-                    }
-                    elseif ($operator == EqualRule::operator) {
+                    } elseif ($operator == EqualRule::operator) {
                         // TODO add an option for the support strict comparison
                         foreach ($operands as $i => $operand) {
                             if (!isset($previous_operand)) {
@@ -402,8 +394,7 @@ 
                             if ($previous_operand == $operand) {
                                 unset($operands[$i]);
                                 continue;
-                            }
-                            else {
+                            } else {
                                 // Same field expected to be two differents
                                 // values at the same time has no sens so
                                 // we remove all the operands of the current
@@ -411,8 +402,7 @@ 
                                 return [];
                             }
                         }
-                    }
-                    elseif ($operator == InRule::operator) {
+                    } elseif ($operator == InRule::operator) {
                         $first_in = reset($operands);
 
                         foreach ($operands as $i => $next_in) {
@@ -432,8 +422,7 @@ 
                         if (!$first_in->getPossibilities()) {
                             return [];
                         }
-                    }
-                    elseif ($operator == NotInRule::operator) {
+                    } elseif ($operator == NotInRule::operator) {
                         $first_not_in = reset($operands);
 
                         foreach ($operands as $i => $next_not_in) {
@@ -449,8 +438,7 @@ 
                             unset($operands[$i]);
                         }
                     }
-                }
-                catch (\Exception $e) {
+                } catch (\Exception $e) {
                     VisibilityViolator::setHiddenProperty($e, 'message', $e->getMessage() . "\n" . var_export([
                             'operands' => $operands,
                             // 'this'     => $this,
@@ -525,12 +513,10 @@ 
                     if ($equalRule->getValue() !== null) {
                         if ($not_equal_rule->getValue() === null) { // means if exists <=> equals something
                             unset($operandsByOperator[ NotEqualRule::operator ][$i]);
-                        }
-                        elseif ($not_equal_rule->getValue() != $equalRule->getValue()) {
+                        } elseif ($not_equal_rule->getValue() != $equalRule->getValue()) {
                             unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                         }
-                    }
-                    elseif ($equalRule->getValue() === null ) {
+                    } elseif ($equalRule->getValue() === null ) {
                         if ($not_equal_rule->getValue() !== null) {
                             unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                         }
@@ -558,8 +544,7 @@ 
 
                 if (in_array($equalRule->getValue(), $possibilities)) {
                     unset($operandsByOperator[ InRule::operator ]);
-                }
-                else {
+                } else {
                     // We flush possibilities of the InRule
                     // TODO Replace it by a FalseRule
                     $operandsByOperator[ InRule::operator ][0]->setPossibilities([]);
@@ -573,8 +558,7 @@ 
                 if (in_array($equalRule->getValue(), $notInRule->getPossibilities())) {
                     // ['field', '=', 4] && ['field', '!in', [4]...] <=> false
                     return [];
-                }
-                else {
+                } else {
                     unset($operandsByOperator[ NotInRule::operator ]);
                 }
                 // $notInRule->dump(true);
@@ -584,8 +568,7 @@ 
                 $belowOrEqualRule = reset($operandsByOperator[ BelowOrEqualRule::operator ]);
                 if ($equalRule->getValue() <= $belowOrEqualRule->getMaximum()) {
                     unset($operandsByOperator[ BelowOrEqualRule::operator ]);
-                }
-                else {
+                } else {
                     // ['field', '=', 4] && ['field', '<=', [3]...] <=> false
                     return [];
                 }
@@ -595,8 +578,7 @@ 
                 $aboveOrEqualRule = reset($operandsByOperator[ AboveOrEqualRule::operator ]);
                 if ($equalRule->getValue() >= $aboveOrEqualRule->getMinimum()) {
                     unset($operandsByOperator[ AboveOrEqualRule::operator ]);
-                }
-                else {
+                } else {
                     // ['field', '=', 4] && ['field', '<=', [3]...] <=> false
                     return [];
                 }
@@ -621,8 +603,7 @@ 
                                 unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                             }
                         }
-                    }
-                    else {
+                    } else {
                         if (!empty($operandsByOperator[ AboveRule::operator ])) {
                             if ($operandsByOperator[ AboveRule::operator ][0]->getMinimum() >= $notEqualRule->getValue()) {
                                 unset($operandsByOperator[ NotEqualRule::operator ][$i]);
@@ -733,8 +714,7 @@ 
                     // [field < 3] && [field <= 3]
                     // [field < 3] && [field <= 4]
                     unset($operandsByOperator[ BelowOrEqualRule::operator ][0]);
-                }
-                else {
+                } else {
                     // [field < 3] && [field <= 2]
                     unset($operandsByOperator[ BelowRule::operator ][0]);
                 }
@@ -755,8 +735,7 @@ 
                 if ($belowOrEqualRule->getMaximum() < $minimum) {
                     // [field <= 3] && [field >= 4] <=> false
                     return [];
-                }
-                elseif ($belowOrEqualRule->getMaximum() == $minimum) {
+                } elseif ($belowOrEqualRule->getMaximum() == $minimum) {
                     // [field <= 3] && [field >= 3] <=> [field = 3]
                     unset($operandsByOperator[ BelowOrEqualRule::operator ]);
                     unset($operandsByOperator[ AboveOrEqualRule::operator ]);
@@ -782,8 +761,7 @@ 
     {
         try {
             return $this->setOperands( $new_operands );
-        }
-        catch (\LogicException $e) {
+        } catch (\LogicException $e) {
             return new AndRule( $new_operands );
         }
     }

src/Rule/OrRule.php

Spacing +18 added lines, -18 removed lines

@@ -19,17 +19,17 @@ 
     public function removeSameOperationOperands(array $simplification_options)
     {
         foreach ($this->operands as $i => &$operand) {
-            if ( ! is_a($operand, OrRule::class)) {
+            if (!is_a($operand, OrRule::class)) {
                 continue;
             }
 
-            if ( !$operand->isNormalizationAllowed($simplification_options) ) {
+            if (!$operand->isNormalizationAllowed($simplification_options)) {
                 continue;
             }
 
             // Id AND is an operand on AND they can be merge (and the same with OR)
             foreach ($operand->getOperands() as $sub_operand) {
-                $this->addOperand( $sub_operand->copy() );
+                $this->addOperand($sub_operand->copy());
             }
             unset($this->operands[$i]);
 
@@ -53,7 +53,7 @@ 
             return $this->copy();
         }
 
-        $this->moveSimplificationStepForward( self::rootify_disjunctions, $simplification_options );
+        $this->moveSimplificationStepForward(self::rootify_disjunctions, $simplification_options);
 
         $upLiftedOperands = [];
         foreach ($this->getOperands() as $operand) {
@@ -80,7 +80,7 @@ 
      *
      * @return array
      */
-    public function toArray(array $options=[])
+    public function toArray(array $options = [])
     {
         $default_options = [
             'show_instance' => false,
@@ -88,8 +88,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;
             }
         }
 
@@ -128,7 +128,7 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         $operator = self::operator;
         if (!$this->operands) {
@@ -143,7 +143,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 .= ']';
@@ -164,7 +164,7 @@ 
 
                 try {
                     if ($operator == AboveRule::operator) {
-                        usort($operands, function( AboveRule $a, AboveRule $b ) {
+                        usort($operands, function(AboveRule $a, AboveRule $b) {
                             if ($a->getMinimum() === null) {
                                 return 1;
                             }
@@ -182,7 +182,7 @@ 
                         $operands = [reset($operands)];
                     }
                     elseif ($operator == BelowRule::operator) {
-                        usort($operands, function( BelowRule $a, BelowRule $b ) {
+                        usort($operands, function(BelowRule $a, BelowRule $b) {
                             if ($a->getMaximum() === null) {
                                 return 1;
                             }
@@ -207,17 +207,17 @@ 
                                 continue;
                             }
 
-                            $first_in->setPossibilities( array_merge(
+                            $first_in->setPossibilities(array_merge(
                                 $first_in->getPossibilities(),
                                 $next_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,
                         ], true)
                     );
@@ -226,7 +226,7 @@ 
                     throw $e;
                 }
 
-                $operandsByFields[ $field ][ $operator ] = $operands;
+                $operandsByFields[$field][$operator] = $operands;
             }
         }
 
@@ -271,7 +271,7 @@ 
      *
      * @return bool If the rule can have a solution or not
      */
-    public function hasSolution(array $simplification_options=[])
+    public function hasSolution(array $simplification_options = [])
     {
         if (!$this->isNormalizationAllowed($simplification_options)) {
             return true;
@@ -298,10 +298,10 @@ 
     public function setOperandsOrReplaceByOperation($new_operands)
     {
         try {
-            return $this->setOperands( $new_operands );
+            return $this->setOperands($new_operands);
         }
         catch (\LogicException $e) {
-            return new OrRule( $new_operands );
+            return new OrRule($new_operands);
         }
     }
 

Braces +8 added lines, -16 removed lines

@@ -66,8 +66,7 @@ 
                 foreach ($operand->getOperands() as $subOperand) {
                     $upLiftedOperands[] = $subOperand;
                 }
-            }
-            else {
+            } else {
                 $upLiftedOperands[] = $operand;
             }
         }
@@ -111,16 +110,14 @@ 
                 [self::operator],
                 $operands_semantic_ids
             );
-        }
-        else {
+        } else {
             foreach ($operands as $operand) {
                 $operands_as_array[] = $operand->toArray($options);
             }
 
             if (!$options['show_instance']) {
                 return $this->cache['array'] = $operands_as_array;
-            }
-            else {
+            } else {
                 return $operands_as_array;
             }
         }
@@ -180,8 +177,7 @@ 
                             return 1;
                         });
                         $operands = [reset($operands)];
-                    }
-                    elseif ($operator == BelowRule::operator) {
+                    } elseif ($operator == BelowRule::operator) {
                         usort($operands, function( BelowRule $a, BelowRule $b ) {
                             if ($a->getMaximum() === null) {
                                 return 1;
@@ -198,8 +194,7 @@ 
                             return 1;
                         });
                         $operands = [reset($operands)];
-                    }
-                    elseif ($operator == InRule::operator) {
+                    } elseif ($operator == InRule::operator) {
                         $first_in = reset($operands);
 
                         foreach ($operands as $i => $next_in) {
@@ -215,8 +210,7 @@ 
                             unset($operands[$i]);
                         }
                     }
-                }
-                catch (\Exception $e) {
+                } catch (\Exception $e) {
                     VisibilityViolator::setHiddenProperty($e, 'message', $e->getMessage() . "\n" . var_export([
                             'operands'          => $operands,
                         ], true)
@@ -254,8 +248,7 @@ 
                     unset($this->operands[$i]);
                     continue;
                 }
-            }
-            else {
+            } else {
                 if (!$this->operands[$i]->hasSolution()) {
                     unset($this->operands[$i]);
                 }
@@ -299,8 +292,7 @@ 
     {
         try {
             return $this->setOperands( $new_operands );
-        }
-        catch (\LogicException $e) {
+        } catch (\LogicException $e) {
             return new OrRule( $new_operands );
         }
     }

src/Rule/BetweenOrEqualLowerRule.php

Braces +1 added lines, -2 removed lines

@@ -21,8 +21,7 @@
             // So if the two limits are equal we only consider the equality
             $this->addOperand( new EqualRule($field, $limits[0]) );
             $this->addOperand( new EqualRule($field, $limits[0]) );
-        }
-        else {
+        } else {
             $this->addOperand( new AboveOrEqualRule($field, $limits[0]) );
             $this->addOperand( new BelowRule($field, $limits[1]) );
         }