jclaveau / php-logical-filter

src/LogicalFilter.php

Spacing +86 added lines, -86 removed lines

@@ -51,12 +51,12 @@ 
      *
      * @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();
         }
-        elseif ( ! is_null($rules) && ! is_array($rules)) {
+        elseif (!is_null($rules) && !is_array($rules)) {
             throw new \InvalidArgumentException(
                 "\$rules must be a rules description or an AbstractRule instead of"
                 .var_export($rules, true)
@@ -72,7 +72,7 @@ 
         }
 
         if ($rules) {
-            $this->and_( $rules );
+            $this->and_($rules);
         }
     }
 
@@ -80,7 +80,7 @@ 
      */
     protected function getDefaultFilterer()
     {
-        if ( ! $this->default_filterer) {
+        if (!$this->default_filterer) {
             $this->default_filterer = new PhpFilterer();
         }
 
@@ -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,27 +352,27 @@ 
 
             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'];
-                    if ( ! $non_true_rule_descriptions) {
+                    if (!$non_true_rule_descriptions) {
                         throw new \LogicException(
                             "TrueRules are not implemented. Please add "
                             ."them to operations having other type of rules"
                         );
                     }
 
-                    unset($operands_descriptions[ $i ]);
+                    unset($operands_descriptions[$i]);
                 }
             }
 
             $remaining_operations = array_filter(
                 $operands_descriptions,
                 function($operand) {
-                    return ! is_array($operand)
-                        && ! $operand instanceof AbstractRule
-                        && ! $operand instanceof LogicalFilter
+                    return !is_array($operand)
+                        && !$operand instanceof AbstractRule
+                        && !$operand instanceof LogicalFilter
                         ;
                 }
             );
@@ -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,9 +537,9 @@ 
      *
      * @return bool
      */
-    public function hasSolution($save_simplification=true)
+    public function hasSolution($save_simplification = true)
     {
-        if ( ! $this->rules) {
+        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,15 +695,15 @@ 
      *
      * @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'];
+        $clean_empty_branches = !isset($options['clean_empty_branches']) || $options['clean_empty_branches'];
 
         $filter = (new LogicalFilter($filter, new RuleFilterer))
         // ->dump()
         ;
 
-        $options[ Filterer::leaves_only ] = true;
+        $options[Filterer::leaves_only] = true;
 
         $this->rules = (new RuleFilterer)->apply($filter, $this->rules, $options);
         // $this->rules->dump(true);
@@ -719,7 +719,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) {
                     },
@@ -744,13 +744,13 @@ 
      *
      * @todo Merge with rules
      */
-    public function listLeafRulesMatching($filter=[])
+    public function listLeafRulesMatching($filter = [])
     {
         $filter = (new LogicalFilter($filter, new RuleFilterer))
         // ->dump()
         ;
 
-        if ( ! $this->rules) {
+        if (!$this->rules) {
             return [];
         }
 
@@ -764,9 +764,9 @@ 
                     $key,
                     array $siblings
                 ) use (&$out) {
-                    if (   ! $matching_rule instanceof AndRule
-                        && ! $matching_rule instanceof OrRule
-                        && ! $matching_rule instanceof NotRule
+                    if (!$matching_rule instanceof AndRule
+                        && !$matching_rule instanceof OrRule
+                        && !$matching_rule instanceof NotRule
                     ) {
                         $out[] = $matching_rule;
                     }
@@ -787,13 +787,13 @@ 
      *
      * @todo Make it available on AbstractRule also
      */
-    public function onEachRule($filter=[], $options)
+    public function onEachRule($filter = [], $options)
     {
         $filter = (new LogicalFilter($filter, new RuleFilterer))
         // ->dump()
         ;
 
-        if ( ! $this->rules) {
+        if (!$this->rules) {
             return [];
         }
 
@@ -818,7 +818,7 @@ 
     {
         $this->simplify(['force_logical_core' => true]);
 
-        if ( ! $this->rules) {
+        if (!$this->rules) {
             return $this;
         }
 
@@ -863,7 +863,7 @@ 
      *
      * @return LogicalFilter
      */
-    public function saveAs( &$variable )
+    public function saveAs(&$variable)
     {
         return $variable = $this;
     }
@@ -874,7 +874,7 @@ 
      *
      * @return LogicalFilter
      */
-    public function saveCopyAs( &$copied_variable )
+    public function saveCopyAs(&$copied_variable)
     {
         $copied_variable = $this->copy();
         return $this;
@@ -887,15 +887,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);
@@ -906,23 +906,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'];
+            if (!isset($caller['file'])) {
+                $caller['file'] = $bt[$callstack_depth - 3]['file'];
             }
-            if ( ! isset($caller['line'])) {
-                $caller['line'] = $bt[ $callstack_depth - 3 ]['line'];
+            if (!isset($caller['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);
@@ -947,15 +947,15 @@ 
      *
      * @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) {
+        if (!$filterer) {
             $filterer = $this->getDefaultFilterer();
         }
         elseif (is_callable($filterer)) {
             $filterer = new CustomizableFilterer($filterer);
         }
-        elseif ( ! $filterer instanceof Filterer) {
+        elseif (!$filterer instanceof Filterer) {
             throw new \InvalidArgumentException(
                  "The given \$filterer must be null or a callable or a instance "
                 ."of Filterer instead of: ".var_export($filterer, true)
@@ -963,11 +963,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);
         }
     }
 
@@ -982,22 +982,22 @@ 
      *                                 + 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) {
+        if (!$filterer) {
             $filterer = $this->getDefaultFilterer();
         }
         elseif (is_callable($filterer)) {
             $filterer = new CustomizableFilterer($filterer);
         }
-        elseif ( ! $filterer instanceof Filterer) {
+        elseif (!$filterer instanceof Filterer) {
             throw new \InvalidArgumentException(
                  "The given \$filterer must be null or a callable or a instance "
                 ."of Filterer instead of: ".var_export($filterer, true)
             );
         }
 
-        return $filterer->hasMatchingCase( $this, $value_to_check, $key_to_check );
+        return $filterer->hasMatchingCase($this, $value_to_check, $key_to_check);
     }
 
     /**/

Braces +28 added lines, -56 removed lines

@@ -55,8 +55,7 @@ 
     {
         if ($rules instanceof AbstractRule) {
             $rules = $rules->copy();
-        }
-        elseif ( ! is_null($rules) && ! is_array($rules)) {
+        } elseif ( ! is_null($rules) && ! is_array($rules)) {
             throw new \InvalidArgumentException(
                 "\$rules must be a rules description or an AbstractRule instead of"
                 .var_export($rules, true)
@@ -148,13 +147,11 @@ 
             if (AndRule::operator == $operation) {
                 // A && True <=> A
                 return $this;
-            }
-            elseif (OrRule::operator == $operation) {
+            } elseif (OrRule::operator == $operation) {
                 // A || True <=> True
                 $this->rules = null;
                 return $this;
-            }
-            else {
+            } else {
                 throw new InvalidArgumentException(
                     "Unhandled operation '$operation'"
                 );
@@ -174,8 +171,7 @@ 
             );
 
             $this->addRule($new_rule, $operation);
-        }
-        elseif (count($rules_description) == count(array_filter($rules_description, function($arg) {
+        } elseif (count($rules_description) == count(array_filter($rules_description, function($arg) {
             return $arg instanceof LogicalFilter;
         })) ) {
             // Already instanciated rules
@@ -185,16 +181,14 @@ 
                     $this->addRule( $rules, $operation);
                 }
             }
-        }
-        elseif (count($rules_description) == count(array_filter($rules_description, function($arg) {
+        } 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);
             }
-        }
-        elseif (1 == count($rules_description) && is_array($rules_description[0])) {
+        } 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;
             })) ) {
@@ -202,8 +196,7 @@ 
                 foreach ($rules_description[0] as $i => $new_rule) {
                     $this->addRule( $new_rule, $operation );
                 }
-            }
-            else {
+            } else {
                 $fake_root = new AndRule;
 
                 $this->addCompositeRule_recursion(
@@ -213,8 +206,7 @@ 
 
                 $this->addRule( $fake_root->getOperands()[0], $operation );
             }
-        }
-        else {
+        } else {
             throw new \InvalidArgumentException(
                 "Bad set of arguments provided for rules addition: "
                 .var_export($rules_description, true)
@@ -245,24 +237,20 @@ 
 
         if (null === $this->rules) {
             $this->rules = $rule;
-        }
-        elseif (($tmp_rules = $this->rules) // $this->rules::operator not supported in PHP 5.6
+        } elseif (($tmp_rules = $this->rules) // $this->rules::operator not supported in PHP 5.6
             && ($tmp_rules::operator != $operation)
         ) {
             if (AndRule::operator == $operation) {
                 $this->rules = new AndRule([$this->rules, $rule]);
-            }
-            elseif (OrRule::operator == $operation) {
+            } elseif (OrRule::operator == $operation) {
                 $this->rules = new OrRule([$this->rules, $rule]);
-            }
-            else {
+            } else {
                 throw new \InvalidArgumentException(
                     "\$operation must be '".AndRule::operator."' or '".OrRule::operator
                     ."' instead of: ".var_export($operation, true)
                 );
             }
-        }
-        else {
+        } else {
             $this->rules->addOperand($rule);
         }
 
@@ -292,8 +280,7 @@ 
                 "Please provide an operator for the operation: \n"
                 .var_export($rules_composition, true)
             );
-        }
-        elseif ( 3 == count($rules_composition)
+        } 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 )
@@ -310,22 +297,18 @@ 
                 $operand_left, $operation, $operand_right, $this->getOptions()
             );
             $recursion_position->addOperand( $rule );
-        }
-        else {
+        } else {
             // operations
             if (   NotRule::operator == $rules_composition[0]
                 || $rules_composition[0] == AbstractRule::findSymbolicOperator( NotRule::operator ) ) {
                 $rule = new NotRule();
-            }
-            elseif (in_array( 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 )
+            } elseif (in_array( OrRule::operator, $rules_composition )
                 || in_array( AbstractRule::findSymbolicOperator( OrRule::operator ), $rules_composition ) ) {
                 $rule = new OrRule();
-            }
-            else {
+            } else {
                 throw new \InvalidArgumentException(
                     "A rule description seems to be an operation but do "
                     ."not contains a valid operator: ".var_export($rules_composition, true)
@@ -353,8 +336,7 @@ 
             foreach ($operands_descriptions as $i => $operands_description) {
                 if (false === $operands_description) {
                     $operands_descriptions[ $i ] = ['and']; // FalseRule hack
-                }
-                elseif (null === $operands_description || true === $operands_description) {
+                } elseif (null === $operands_description || true === $operands_description) {
                     $operands_description = ['and'];
                     if ( ! $non_true_rule_descriptions) {
                         throw new \LogicException(
@@ -395,11 +377,9 @@ 
             foreach ($operands_descriptions as $operands_description) {
                 if ($operands_description instanceof AbstractRule) {
                     $rule->addOperand($operands_description);
-                }
-                elseif ($operands_description instanceof LogicalFilter) {
+                } elseif ($operands_description instanceof LogicalFilter) {
                     $rule->addOperand($operands_description->getRules());
-                }
-                else {
+                } else {
                     $this->addCompositeRule_recursion(
                         $operands_description,
                         $rule
@@ -634,8 +614,7 @@ 
     {
         if (method_exists($this->rules, 'renameField')) {
             $this->rules->renameField($renamings);
-        }
-        elseif ($this->rules) {
+        } elseif ($this->rules) {
             $this->rules->renameFields($renamings);
         }
 
@@ -902,8 +881,7 @@ 
 
         if ($this->rules) {
             $this->rules->dump($exit, $options);
-        }
-        else {
+        } else {
             // TODO dump a TrueRule
             $bt     = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, $callstack_depth);
             $caller = $bt[ $callstack_depth - 2 ];
@@ -920,8 +898,7 @@ 
             try {
                 echo "\n" . $caller['file'] . ':' . $caller['line'] . "\n";
                 var_export($this->toArray($options));
-            }
-            catch (\Exception $e) {
+            } catch (\Exception $e) {
                 echo "\nError while dumping: " . $e->getMessage() . "\n";
                 var_export($caller);
                 echo "\n\n";
@@ -951,11 +928,9 @@ 
     {
         if ( ! $filterer) {
             $filterer = $this->getDefaultFilterer();
-        }
-        elseif (is_callable($filterer)) {
+        } elseif (is_callable($filterer)) {
             $filterer = new CustomizableFilterer($filterer);
-        }
-        elseif ( ! $filterer instanceof Filterer) {
+        } elseif ( ! $filterer instanceof Filterer) {
             throw new \InvalidArgumentException(
                  "The given \$filterer must be null or a callable or a instance "
                 ."of Filterer instead of: ".var_export($filterer, true)
@@ -965,8 +940,7 @@ 
         if ($data_to_filter instanceof LogicalFilter) {
             $filtered_rules = $filterer->apply( $this, $data_to_filter->getRules() );
             return $data_to_filter->flushRules()->addRule( $filtered_rules );
-        }
-        else {
+        } else {
             return $filterer->apply( $this, $data_to_filter );
         }
     }
@@ -986,11 +960,9 @@ 
     {
         if ( ! $filterer) {
             $filterer = $this->getDefaultFilterer();
-        }
-        elseif (is_callable($filterer)) {
+        } elseif (is_callable($filterer)) {
             $filterer = new CustomizableFilterer($filterer);
-        }
-        elseif ( ! $filterer instanceof Filterer) {
+        } elseif ( ! $filterer instanceof Filterer) {
             throw new \InvalidArgumentException(
                  "The given \$filterer must be null or a callable or a instance "
                 ."of Filterer instead of: ".var_export($filterer, true)

src/Filterer/Filterer.php

Spacing +26 added lines, -26 removed lines

@@ -46,11 +46,11 @@ 
      */
     public function onRowMatches(&$row, $key, &$rows, $matching_case, $options)
     {
-        if (isset($options[ self::on_row_matches ])) {
-            $callback = $options[ self::on_row_matches ];
+        if (isset($options[self::on_row_matches])) {
+            $callback = $options[self::on_row_matches];
         }
-        elseif (isset($this->custom_actions[ self::on_row_matches ])) {
-            $callback = $this->custom_actions[ self::on_row_matches ];
+        elseif (isset($this->custom_actions[self::on_row_matches])) {
+            $callback = $this->custom_actions[self::on_row_matches];
         }
         else {
             return;
@@ -72,20 +72,20 @@ 
      */
     public function onRowMismatches(&$row, $key, &$rows, $matching_case, $options)
     {
-        if (   ! $this->custom_actions
-            && ! isset($options[self::on_row_mismatches])
-            && ! isset($options[self::on_row_matches])
+        if (!$this->custom_actions
+            && !isset($options[self::on_row_mismatches])
+            && !isset($options[self::on_row_matches])
         ) {
             // Unset by default ONLY if NO custom action defined
             unset($rows[$key]);
             return;
         }
 
-        if (isset($options[ self::on_row_mismatches ])) {
-            $callback = $options[ self::on_row_mismatches ];
+        if (isset($options[self::on_row_mismatches])) {
+            $callback = $options[self::on_row_mismatches];
         }
-        elseif (isset($this->custom_actions[ self::on_row_mismatches ])) {
-            $callback = $this->custom_actions[ self::on_row_mismatches ];
+        elseif (isset($this->custom_actions[self::on_row_mismatches])) {
+            $callback = $this->custom_actions[self::on_row_mismatches];
         }
         else {
             return;
@@ -122,7 +122,7 @@ 
      * @param Iterable        $tree_to_filter
      * @param array           $options
      */
-    public function apply( LogicalFilter $filter, $tree_to_filter, $options=[] )
+    public function apply(LogicalFilter $filter, $tree_to_filter, $options = [])
     {
         $root_OrRule = $filter
             ->simplify(['force_logical_core' => true])
@@ -131,7 +131,7 @@ 
             ;
 
         if (null !== $root_OrRule) {
-            if ( ! $root_OrRule->hasSolution()) {
+            if (!$root_OrRule->hasSolution()) {
                 return null;
             }
 
@@ -141,10 +141,10 @@ 
             $root_cases = [];
         }
 
-        if ( ! isset($options['recurse'])) {
+        if (!isset($options['recurse'])) {
             $options['recurse'] = 'before';
         }
-        elseif ( ! in_array($options['recurse'], ['before', 'after', null])) {
+        elseif (!in_array($options['recurse'], ['before', 'after', null])) {
             throw new \InvalidArgumentException(
                 "Invalid value for 'recurse' option: "
                 .var_export($options['recurse'], true)
@@ -155,14 +155,14 @@ 
         return $this->foreachRow(
             $root_cases,
             $tree_to_filter,
-            $path=[],
+            $path = [],
             $options
         );
     }
 
     /**
      */
-    protected function foreachRow(array $root_cases, $tree_to_filter, array $path, $options=[])
+    protected function foreachRow(array $root_cases, $tree_to_filter, array $path, $options = [])
     {
         // Once the rules are prepared, we parse the data
         foreach ($tree_to_filter as $row_index => $row_to_filter) {
@@ -221,7 +221,7 @@ 
      *
      * @return bool
      */
-    public function hasMatchingCase( LogicalFilter $filter, $row_to_check, $key_to_check, $options=[] )
+    public function hasMatchingCase(LogicalFilter $filter, $row_to_check, $key_to_check, $options = [])
     {
         $root_OrRule = $filter
             ->simplify(['force_logical_core' => true])
@@ -230,7 +230,7 @@ 
             ;
 
         if (null !== $root_OrRule) {
-            if ( ! $root_OrRule->hasSolution()) {
+            if (!$root_OrRule->hasSolution()) {
                 return null;
             }
 
@@ -243,24 +243,24 @@ 
         return $this->applyOnRow(
             $root_cases,
             $row_to_check,
-            $path=[$key_to_check],
+            $path = [$key_to_check],
             $options
         );
     }
 
     /**
      */
-    protected function applyOnRow(array $root_cases, $row_to_filter, array $path, $options=[])
+    protected function applyOnRow(array $root_cases, $row_to_filter, array $path, $options = [])
     {
         $operands_validation_row_cache = [];
 
-        if ( ! $root_cases) {
+        if (!$root_cases) {
             $matching_case = true;
         }
         else {
             $matching_case = null;
             foreach ($root_cases as $and_case_index => $and_case) {
-                if ( ! empty($options['debug'])) {
+                if (!empty($options['debug'])) {
                     var_dump("Case $and_case_index: ".$and_case);
                 }
 
@@ -288,8 +288,8 @@ 
 
                     $cache_key = $and_case_index.'~|~'.$field.'~|~'.$operator;
 
-                    if ( ! empty($operands_validation_row_cache[ $cache_key ])) {
-                        $is_valid = $operands_validation_row_cache[ $cache_key ];
+                    if (!empty($operands_validation_row_cache[$cache_key])) {
+                        $is_valid = $operands_validation_row_cache[$cache_key];
                     }
                     else {
                         $is_valid = $this->validateRule(
@@ -302,7 +302,7 @@ 
                             $options
                         );
 
-                        $operands_validation_row_cache[ $cache_key ] = $is_valid;
+                        $operands_validation_row_cache[$cache_key] = $is_valid;
                     }
 
                     if (false === $is_valid) {

Braces +16 added lines, -32 removed lines

@@ -48,11 +48,9 @@ 
     {
         if (isset($options[ self::on_row_matches ])) {
             $callback = $options[ self::on_row_matches ];
-        }
-        elseif (isset($this->custom_actions[ self::on_row_matches ])) {
+        } elseif (isset($this->custom_actions[ self::on_row_matches ])) {
             $callback = $this->custom_actions[ self::on_row_matches ];
-        }
-        else {
+        } else {
             return;
         }
 
@@ -83,11 +81,9 @@ 
 
         if (isset($options[ self::on_row_mismatches ])) {
             $callback = $options[ self::on_row_mismatches ];
-        }
-        elseif (isset($this->custom_actions[ self::on_row_mismatches ])) {
+        } elseif (isset($this->custom_actions[ self::on_row_mismatches ])) {
             $callback = $this->custom_actions[ self::on_row_mismatches ];
-        }
-        else {
+        } else {
             return;
         }
 
@@ -136,15 +132,13 @@ 
             }
 
             $root_cases = $root_OrRule->getOperands();
-        }
-        else {
+        } else {
             $root_cases = [];
         }
 
         if ( ! isset($options['recurse'])) {
             $options['recurse'] = 'before';
-        }
-        elseif ( ! in_array($options['recurse'], ['before', 'after', null])) {
+        } elseif ( ! in_array($options['recurse'], ['before', 'after', null])) {
             throw new \InvalidArgumentException(
                 "Invalid value for 'recurse' option: "
                 .var_export($options['recurse'], true)
@@ -185,12 +179,10 @@ 
 
             if ($matching_case) {
                 $this->onRowMatches($row_to_filter, $row_index, $tree_to_filter, $matching_case, $options);
-            }
-            elseif (false === $matching_case) {
+            } elseif (false === $matching_case) {
                 // No case match the rule
                 $this->onRowMismatches($row_to_filter, $row_index, $tree_to_filter, $matching_case, $options);
-            }
-            elseif (null === $matching_case) {
+            } elseif (null === $matching_case) {
                 // We simply avoid rules
                 // row out of scope
             }
@@ -235,8 +227,7 @@ 
             }
 
             $root_cases = $root_OrRule->getOperands();
-        }
-        else {
+        } else {
             $root_cases = [];
         }
 
@@ -256,8 +247,7 @@ 
 
         if ( ! $root_cases) {
             $matching_case = true;
-        }
-        else {
+        } else {
             $matching_case = null;
             foreach ($root_cases as $and_case_index => $and_case) {
                 if ( ! empty($options['debug'])) {
@@ -269,16 +259,14 @@ 
                     if ($rule instanceof OrRule && $rule instanceof AndRule) {
                         $field = null;
                         $value = $rule->getOperands();
-                    }
-                    elseif ($rule instanceof NotEqualRule
+                    } elseif ($rule instanceof NotEqualRule
                         || $rule instanceof AbstractAtomicRule
                         || $rule instanceof InRule
                         || $rule instanceof NotInRule
                     ) {
                         $field = $rule->getField();
                         $value = $rule->getValues();
-                    }
-                    else {
+                    } else {
                         throw new \LogicException(
                             "Filtering with a rule which has not been simplified: $rule"
                         );
@@ -290,8 +278,7 @@ 
 
                     if ( ! empty($operands_validation_row_cache[ $cache_key ])) {
                         $is_valid = $operands_validation_row_cache[ $cache_key ];
-                    }
-                    else {
+                    } else {
                         $is_valid = $this->validateRule(
                             $field,
                             $operator,
@@ -310,8 +297,7 @@ 
                         // so all the and_case is invalid
                         $case_is_good = false;
                         break;
-                    }
-                    elseif (true === $is_valid) {
+                    } elseif (true === $is_valid) {
                         // one of the rules of the and_case do not validate
                         // so all the and_case is invalid
                         $case_is_good = true;
@@ -322,11 +308,9 @@ 
                     // at least one and_case works so we can stop here
                     $matching_case = $and_case;
                     break;
-                }
-                elseif (false === $case_is_good) {
+                } elseif (false === $case_is_good) {
                     $matching_case = false;
-                }
-                elseif (null === $case_is_good) {
+                } elseif (null === $case_is_good) {
                     // row out of scope
                 }
             }

src/Filterer/RuleFilterer.php

Spacing +23 added lines, -23 removed lines

@@ -59,10 +59,10 @@ 
 
     /**
      */
-    public function setChildren( &$row, $filtered_children ) // strict issue if forcing  AbstractRule with php 5.6 here
+    public function setChildren(&$row, $filtered_children) // strict issue if forcing  AbstractRule with php 5.6 here
     {
         if ($row instanceof AbstractOperationRule) {
-            return $row->setOperandsOrReplaceByOperation( $filtered_children, [] ); // no simplification options?
+            return $row->setOperandsOrReplaceByOperation($filtered_children, []); // no simplification options?
         }
     }
 
@@ -70,17 +70,17 @@ 
      *
      * @return true | false | null
      */
-    public function validateRule ($field, $operator, $value, $rule, array $path, $all_operands, $options)
+    public function validateRule($field, $operator, $value, $rule, array $path, $all_operands, $options)
     {
-        if (    ! empty($options[ Filterer::leaves_only ])
-            && in_array( get_class($rule), [OrRule::class, AndRule::class, NotRule::class] )
+        if (!empty($options[Filterer::leaves_only])
+            && in_array(get_class($rule), [OrRule::class, AndRule::class, NotRule::class])
         ) {
             // return true;
             return null;
         }
 
         if (self::field === $field) {
-            if ( ! method_exists($rule, 'getField')) {
+            if (!method_exists($rule, 'getField')) {
                 // if (in_array( get_class($rule), [AndRule::class, OrRule::class]))
                 return null; // The filter cannot be applied to this rule
             }
@@ -100,9 +100,9 @@ 
         elseif (self::value === $field) {
             $description = $rule->toArray();
 
-            if (    3 === count($description)
+            if (3 === count($description)
                 && is_string($description[0])
-                && is_string($description[1]) ) {
+                && is_string($description[1])) {
                 $value_to_compare = $description[2];
             }
             else {
@@ -121,10 +121,10 @@ 
             throw new \InvalidArgumentException('Path rule uppport not implemented');
         }
         elseif (self::children === $field) {
-            if ( ! method_exists($rule, 'getOperands')) {
+            if (!method_exists($rule, 'getOperands')) {
                 return null; // The filter cannot be applied to this rule
             }
-            $value_to_compare = count( $rule->getOperands() );
+            $value_to_compare = count($rule->getOperands());
         }
         else {
             throw new \InvalidArgumentException(
@@ -173,27 +173,27 @@ 
         }
         elseif (NotEqualRule::operator === $operator) {
             if (null === $value) {
-                $out = ! is_null($value_to_compare);
+                $out = !is_null($value_to_compare);
             }
             else {
                 $out = $value != $value_to_compare;
             }
         }
         elseif (NotInRule::operator === $operator) {
-            $out = ! in_array($value_to_compare, $value);
+            $out = !in_array($value_to_compare, $value);
         }
         else {
             throw new \InvalidArgumentException(
-                "Unhandled operator: " . $operator
+                "Unhandled operator: ".$operator
             );
         }
 
-        if ( ! empty($options['debug'])) {
+        if (!empty($options['debug'])) {
             var_dump(
-                "$field, $operator, " . var_export($value, true)
-                 . ' ||  '. $value_to_compare . ' => ' . var_export($out, true)
-                 . "\n" . get_class($rule)
-                 . "\n" . var_export($options, true)
+                "$field, $operator, ".var_export($value, true)
+                 . ' ||  '.$value_to_compare.' => '.var_export($out, true)
+                 . "\n".get_class($rule)
+                 . "\n".var_export($options, true)
             );
             // $rule->dump();
         }
@@ -206,9 +206,9 @@ 
      * @param array|AbstractRule $ruleTree_to_filter
      * @param array              $options leaves_only | debug
      */
-    public function apply( LogicalFilter $filter, $ruleTree_to_filter, $options=[] )
+    public function apply(LogicalFilter $filter, $ruleTree_to_filter, $options = [])
     {
-        if ( ! $ruleTree_to_filter) {
+        if (!$ruleTree_to_filter) {
             return $ruleTree_to_filter;
         }
 
@@ -216,17 +216,17 @@ 
             $ruleTree_to_filter = [$ruleTree_to_filter];
         }
 
-        if ( ! is_array($ruleTree_to_filter)) {
+        if (!is_array($ruleTree_to_filter)) {
             throw new \InvalidArgumentException(
                 "\$ruleTree_to_filter must be an array or an AbstractRule "
-                ."instead of: " . var_export($ruleTree_to_filter, true)
+                ."instead of: ".var_export($ruleTree_to_filter, true)
             );
         }
 
         // Produces "Only variables should be passed by reference" on Travis
         $result = parent::apply($filter, $ruleTree_to_filter, $options);
 
-        return reset( $result );
+        return reset($result);
     }
 
     /**/

Braces +18 added lines, -36 removed lines

@@ -87,46 +87,37 @@ 
 
             try {
                 $value_to_compare = $rule->getField();
-            }
-            catch (\LogicException $e) {
+            } catch (\LogicException $e) {
                 // This is due to NotInRule.
                 // TODO replace it by a TrueRule in this case
                 return  null;
             }
-        }
-        elseif (self::operator === $field) {
+        } elseif (self::operator === $field) {
             $value_to_compare = $rule::operator;
-        }
-        elseif (self::value === $field) {
+        } elseif (self::value === $field) {
             $description = $rule->toArray();
 
             if (    3 === count($description)
                 && is_string($description[0])
                 && is_string($description[1]) ) {
                 $value_to_compare = $description[2];
-            }
-            else {
+            } else {
                 return null; // The filter cannot be applied to this rule
             }
-        }
-        elseif (self::description === $field) {
+        } elseif (self::description === $field) {
             $value_to_compare = $rule->toArray();
-        }
-        elseif (self::depth === $field) {
+        } elseif (self::depth === $field) {
             // original $depth is lost once the filter is simplified
             throw new \InvalidArgumentException('Depth rule uppport not implemented');
-        }
-        elseif (self::path === $field) {
+        } elseif (self::path === $field) {
             // TODO the description of its parents
             throw new \InvalidArgumentException('Path rule uppport not implemented');
-        }
-        elseif (self::children === $field) {
+        } elseif (self::children === $field) {
             if ( ! method_exists($rule, 'getOperands')) {
                 return null; // The filter cannot be applied to this rule
             }
             $value_to_compare = count( $rule->getOperands() );
-        }
-        else {
+        } else {
             throw new \InvalidArgumentException(
                 "Rule filters must belong to ["
                 . implode(', ', [
@@ -145,22 +136,17 @@ 
         if (EqualRule::operator === $operator) {
             if (null === $value) {
                 $out = is_null($value_to_compare);
-            }
-            else {
+            } else {
                 // TODO support strict comparisons
                 $out = $value_to_compare == $value;
             }
-        }
-        elseif (InRule::operator === $operator) {
+        } elseif (InRule::operator === $operator) {
             $out = in_array($value_to_compare, $value);
-        }
-        elseif (BelowRule::operator === $operator) {
+        } elseif (BelowRule::operator === $operator) {
             $out = $value_to_compare < $value;
-        }
-        elseif (AboveRule::operator === $operator) {
+        } elseif (AboveRule::operator === $operator) {
             $out = $value_to_compare > $value;
-        }
-        elseif (RegexpRule::operator === $operator) {
+        } elseif (RegexpRule::operator === $operator) {
             // TODO support optionnal parameters
             $out = preg_match($value, $value_to_compare);
             if (false === $out) {
@@ -170,19 +156,15 @@ 
                 );
             }
             $out = (bool) $out;
-        }
-        elseif (NotEqualRule::operator === $operator) {
+        } elseif (NotEqualRule::operator === $operator) {
             if (null === $value) {
                 $out = ! is_null($value_to_compare);
-            }
-            else {
+            } else {
                 $out = $value != $value_to_compare;
             }
-        }
-        elseif (NotInRule::operator === $operator) {
+        } elseif (NotInRule::operator === $operator) {
             $out = ! in_array($value_to_compare, $value);
-        }
-        else {
+        } else {
             throw new \InvalidArgumentException(
                 "Unhandled operator: " . $operator
             );

src/Filterer/PhpFilterer.php

Spacing +12 added lines, -12 removed lines

@@ -22,23 +22,23 @@ 
 {
     /**
      */
-    public function validateRule ($field, $operator, $value, $row, array $path, $all_operands, $options)
+    public function validateRule($field, $operator, $value, $row, array $path, $all_operands, $options)
     {
         if ($field instanceof FilteredValue) {
-            $value_to_validate = $field( $row );
+            $value_to_validate = $field($row);
         }
         elseif ($field instanceof FilteredKey) {
-            $value_to_validate = $field( array_pop($path) );
+            $value_to_validate = $field(array_pop($path));
         }
-        elseif ( ! isset($row[(string) $field])) {
+        elseif (!isset($row[(string) $field])) {
             $value_to_validate = null;
         }
         else {
-            $value_to_validate = $row[ $field ];
+            $value_to_validate = $row[$field];
         }
 
         if (EqualRule::operator === $operator) {
-            if ( ! isset($value_to_validate)) {
+            if (!isset($value_to_validate)) {
                 // ['field', '=', null] <=> isset($row['field'])
                 // [row, '=', null] <=> $row !== null
                 $result = null === $value;
@@ -49,7 +49,7 @@ 
             }
         }
         elseif (InRule::operator === $operator) {
-            if ( ! isset($value_to_validate)) {
+            if (!isset($value_to_validate)) {
                 $result = false;
             }
             else {
@@ -57,7 +57,7 @@ 
             }
         }
         elseif (BelowRule::operator === $operator) {
-            if ( ! isset($value_to_validate)) {
+            if (!isset($value_to_validate)) {
                 $result = false;
             }
             else {
@@ -65,7 +65,7 @@ 
             }
         }
         elseif (AboveRule::operator === $operator) {
-            if ( ! isset($value_to_validate)) {
+            if (!isset($value_to_validate)) {
                 $result = false;
             }
             else {
@@ -81,16 +81,16 @@ 
             }
         }
         elseif (NotInRule::operator === $operator) {
-            if ( ! isset($value_to_validate)) {
+            if (!isset($value_to_validate)) {
                 $result = true;
             }
             else {
-                $result = ! in_array($value_to_validate, $value);
+                $result = !in_array($value_to_validate, $value);
             }
         }
         else {
             throw new \InvalidArgumentException(
-                "Unhandled operator: " . $operator
+                "Unhandled operator: ".$operator
             );
         }
 

Braces +15 added lines, -30 removed lines

@@ -26,14 +26,11 @@ 
     {
         if ($field instanceof FilteredValue) {
             $value_to_validate = $field( $row );
-        }
-        elseif ($field instanceof FilteredKey) {
+        } elseif ($field instanceof FilteredKey) {
             $value_to_validate = $field( array_pop($path) );
-        }
-        elseif ( ! isset($row[(string) $field])) {
+        } elseif ( ! isset($row[(string) $field])) {
             $value_to_validate = null;
-        }
-        else {
+        } else {
             $value_to_validate = $row[ $field ];
         }
 
@@ -42,53 +39,41 @@ 
                 // ['field', '=', null] <=> isset($row['field'])
                 // [row, '=', null] <=> $row !== null
                 $result = null === $value;
-            }
-            else {
+            } else {
                 // TODO support strict comparisons
                 $result = $value_to_validate == $value;
             }
-        }
-        elseif (InRule::operator === $operator) {
+        } elseif (InRule::operator === $operator) {
             if ( ! isset($value_to_validate)) {
                 $result = false;
-            }
-            else {
+            } else {
                 $result = in_array($value_to_validate, $value);
             }
-        }
-        elseif (BelowRule::operator === $operator) {
+        } elseif (BelowRule::operator === $operator) {
             if ( ! isset($value_to_validate)) {
                 $result = false;
-            }
-            else {
+            } else {
                 $result = $value_to_validate < $value;
             }
-        }
-        elseif (AboveRule::operator === $operator) {
+        } elseif (AboveRule::operator === $operator) {
             if ( ! isset($value_to_validate)) {
                 $result = false;
-            }
-            else {
+            } else {
                 $result = $value_to_validate > $value;
             }
-        }
-        elseif (NotEqualRule::operator === $operator) {
+        } elseif (NotEqualRule::operator === $operator) {
             if (null === $value) {
                 $result = isset($value_to_validate);
-            }
-            else {
+            } else {
                 $result = $value_to_validate != $value;
             }
-        }
-        elseif (NotInRule::operator === $operator) {
+        } elseif (NotInRule::operator === $operator) {
             if ( ! isset($value_to_validate)) {
                 $result = true;
-            }
-            else {
+            } else {
                 $result = ! in_array($value_to_validate, $value);
             }
-        }
-        else {
+        } else {
             throw new \InvalidArgumentException(
                 "Unhandled operator: " . $operator
             );

src/Rule/BelowOrEqualRule.php

Spacing +12 added lines, -12 removed lines

@@ -18,9 +18,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, array $options=[])
+    public function __construct($field, $maximum, array $options = [])
     {
-        if ( ! empty($options)) {
+        if (!empty($options)) {
             $this->setOptions($options);
         }
 
@@ -63,7 +63,7 @@ 
     /**
      * @return bool
      */
-    public function isNormalizationAllowed(array $contextual_options=[])
+    public function isNormalizationAllowed(array $contextual_options = [])
     {
         return $this->getOption('below_or_equal.normalization', $contextual_options);
     }
@@ -73,7 +73,7 @@ 
      */
     public function getOperands()
     {
-        if ( ! empty($this->cache['operands'])) {
+        if (!empty($this->cache['operands'])) {
             return $this->cache['operands'];
         }
 
@@ -105,9 +105,9 @@ 
             }
         }
 
-        if (   2 != count($operands)
-            || ! isset($equalRuleValue)
-            || ! isset($belowRuleValue)
+        if (2 != count($operands)
+            || !isset($equalRuleValue)
+            || !isset($belowRuleValue)
             || $belowRuleValue != $equalRuleValue
             || $belowRuleField != $equalRuleField
         ) {
@@ -136,14 +136,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;
             }
         }
 
@@ -162,7 +162,7 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         if (isset($this->cache['string'])) {
             return $this->cache['string'];
@@ -170,7 +170,7 @@ 
 
         $operator = self::operator;
 
-        return $this->cache['string'] = "['{$this->getField()}', '$operator', " . var_export($this->getValues(), true). "]";
+        return $this->cache['string'] = "['{$this->getField()}', '$operator', ".var_export($this->getValues(), true)."]";
     }
 
     /**/

src/Rule/AbstractOperationRule.php

Spacing +58 added lines, -58 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,30 +128,30 @@ 
      * @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)) {
+        if (!in_array($step_to_go_to, self::simplification_steps)) {
             throw new \InvalidArgumentException(
                 "Invalid simplification step to go to: ".$step_to_go_to
             );
         }
 
         // if ($this->isNormalizationAllowed($simplification_options) && !$force && $this->current_simplification_step != null) {
-        if ( ! $force && null !== $this->current_simplification_step) {
+        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
                 );
             }
         }
@@ -168,7 +168,7 @@ 
      */
     public function simplicationStepReached($step)
     {
-        if ( ! in_array($step, self::simplification_steps)) {
+        if (!in_array($step, self::simplification_steps)) {
             throw new \InvalidArgumentException(
                 "Invalid simplification step: ".$step
             );
@@ -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;
     }
@@ -193,7 +193,7 @@ 
      */
     public function removeNegations(array $contextual_options)
     {
-        if ( ! $this->isNormalizationAllowed($contextual_options)) {
+        if (!$this->isNormalizationAllowed($contextual_options)) {
             return $this;
         }
 
@@ -207,7 +207,7 @@ 
                 }
 
                 if ($operands[$i] instanceof AbstractOperationRule) {
-                    $operands[$i]->removeNegations( $contextual_options );
+                    $operands[$i]->removeNegations($contextual_options);
                 }
             }
 
@@ -227,14 +227,14 @@ 
      *
      * @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
-                && ! $operand instanceof InRule
-                && ! $operand instanceof NotEqualRule
-                && ! $operand instanceof NotInRule
+                if ($operand instanceof AbstractOperationRule
+                && !$operand instanceof InRule
+                && !$operand instanceof NotEqualRule
+                && !$operand instanceof NotInRule
             ) {
                     $this->operands[$i] = $operand->cleanOperations($simplification_options);
                 }
@@ -273,11 +273,11 @@ 
     public function removeMonooperandOperationsOperands(array $simplification_options)
     {
         foreach ($this->operands as $i => $operand) {
-            if ( ! $operand instanceof AbstractOperationRule || $operand instanceof NotRule) {
+            if (!$operand instanceof AbstractOperationRule || $operand instanceof NotRule) {
                 continue;
             }
 
-            if ($operand instanceof InRule && ! $operand->isNormalizationAllowed($simplification_options)) {
+            if ($operand instanceof InRule && !$operand->isNormalizationAllowed($simplification_options)) {
                 $count = count($operand->getPossibilities());
             }
             else {
@@ -294,7 +294,7 @@ 
             }
         }
 
-        return ! empty($has_been_changed);
+        return !empty($has_been_changed);
     }
 
     /**
@@ -305,12 +305,12 @@ 
     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);
 
-        if ( ! $this->isNormalizationAllowed($contextual_options)) {
+        if (!$this->isNormalizationAllowed($contextual_options)) {
             return $this;
         }
 
@@ -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,13 +365,13 @@ 
      *
      * @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;
-        $force_logical_core  = ! empty($options['force_logical_core']) ? $options['force_logical_core'] : false;
+        $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)) {
+        if ($step_to_stop_before && !in_array($step_to_stop_before, self::simplification_steps)) {
             throw new \InvalidArgumentException(
                 "Invalid simplification step to stop at: ".$step_to_stop_before
             );
@@ -406,7 +406,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;
         }
 
@@ -418,18 +418,18 @@ 
         // $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;
         }
 
-        if ( ! $instance instanceof AbstractAtomicRule) {
+        if (!$instance instanceof AbstractAtomicRule) {
             $instance->cleanOperations($options);
             $instance->unifyAtomicOperands(true, $options);
 
             // $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;
             }
 
@@ -446,8 +446,8 @@ 
         // 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->getOperands()) {
+        if ($instance instanceof AndRule || $instance instanceof OrRule) {
+            if (!$instance->getOperands()) {
                 return $instance;
             }
 
@@ -466,7 +466,7 @@ 
             $instance = $instance->forceLogicalCore();
             // for the simplification status at
             foreach ($operands = $instance->getOperands() as $andOperand) {
-                if ( ! $andOperand instanceof AndRule) {
+                if (!$andOperand instanceof AndRule) {
                     throw new \LogicException(
                         "A rule is intended to be an and case: \n"
                         .$andOperand
@@ -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])) {

src/Rule/AbstractRule.php

Spacing +21 added lines, -21 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 ('string' == $mode) {
-            if ( ! isset($options['indent_unit'])) {
+            if (!isset($options['indent_unit'])) {
                 $options['indent_unit'] = "    ";
             }
 
@@ -157,10 +157,10 @@ 
             }
         }
         elseif ('xdebug' == $mode) {
-            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))
               ;
     }
 
@@ -296,7 +296,7 @@ 
         }
         elseif ($this instanceof OrRule) {
             foreach ($this->operands as $i => $operand) {
-                if ( ! $operand instanceof AndRule) {
+                if (!$operand instanceof AndRule) {
                     $this->operands[$i] = new AndRule([$operand]);
                 }
             }

Braces +7 added lines, -14 removed lines

@@ -144,8 +144,7 @@ 
             }
 
             echo ($this->toString($options));
-        }
-        elseif ('dump' == $mode) {
+        } elseif ('dump' == $mode) {
             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 ('xdebug' == $mode) {
+        } elseif ('xdebug' == $mode) {
             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 ('export' == $mode) {
+        } elseif ('export' == $mode) {
             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/NotRule.php

Braces +14 added lines, -28 removed lines

@@ -60,37 +60,30 @@ 
                 new BelowRule($field, $operand->getMinimum()),
                 new EqualRule($field, $operand->getMinimum()),
             ]);
-        }
-        elseif ($operand instanceof BelowRule) {
+        } elseif ($operand instanceof BelowRule) {
             // ! (v >  a) : v <= a : (v < a || a = v)
             $new_rule = new OrRule([
                 new AboveRule($field, $operand->getMaximum()),
                 new EqualRule($field, $operand->getMaximum()),
             ]);
-        }
-        elseif ($operand instanceof NotRule) {
+        } elseif ($operand instanceof NotRule) {
             // ! (  !  a) : a
             $new_rule = $operand->getOperandAt(0);
-        }
-        elseif ($operand instanceof EqualRule && null === $operand->getValue()) {
+        } elseif ($operand instanceof EqualRule && null === $operand->getValue()) {
             $new_rule = new NotEqualRule($field, null);
-        }
-        elseif ($operand instanceof EqualRule) {
+        } elseif ($operand instanceof EqualRule) {
             // ! (v =  a) : (v < a) || (v > a)
             if ($this->getOption('not_equal.normalization', $current_simplification_options)) {
                 $new_rule = new OrRule([
                     new AboveRule($field, $operand->getValue()),
                     new BelowRule($field, $operand->getValue()),
                 ]);
-            }
-            else {
+            } else {
                 $new_rule = new NotEqualRule( $field, $operand->getValue() );
             }
-        }
-        elseif ($operand instanceof NotEqualRule) {
+        } elseif ($operand instanceof NotEqualRule) {
             $new_rule = new EqualRule( $field, $operand->getValue() );
-        }
-        elseif ($operand instanceof AndRule) {
+        } elseif ($operand instanceof AndRule) {
             // @see https://github.com/jclaveau/php-logical-filter/issues/40
             // ! (B && A) : (!B && A) || (B && !A) || (!B && !A)
             // ! (A && B && C) :
@@ -138,8 +131,7 @@ 
             $new_rule->setOperands( $combinations )
                 // ->dump(true)
                 ;
-        }
-        elseif ($operand instanceof OrRule) {
+        } elseif ($operand instanceof OrRule) {
 
             // $operand->dump(true);
             if (     $operand instanceof InRule
@@ -150,8 +142,7 @@ 
                     $operand->getField(),
                     $operand->getPossibilities()
                 );
-            }
-            else {
+            } else {
                 // ! (A || B) : !A && !B
                 // ! (A || B || C || D) : !A && !B && !C && !D
                 $new_rule = new AndRule;
@@ -165,8 +156,7 @@ 
                 }
             }
             // $new_rule->dump(!true);
-        }
-        else {
+        } else {
             throw new \LogicException(
                 'Removing NotRule(' . var_export($operand, true) . ') '
                 . ' not implemented'
@@ -250,8 +240,7 @@ 
         // TODO make a dedicated cache entry for semantic array?
         if ( ! $options['show_instance'] && ! $options['semantic']) {
             return $this->cache['array'] = $array;
-        }
-        else {
+        } else {
             return $array;
         }
     }
@@ -307,19 +296,16 @@ 
         if ($new_operand instanceof NotRule) {
             $operands = $new_operand->getOperands();
             return reset( $operands );
-        }
-        elseif ($new_operand instanceof EqualRule && ! $this->getOption('not_equal.normalization', $contextual_options)) {
+        } elseif ($new_operand instanceof EqualRule && ! $this->getOption('not_equal.normalization', $contextual_options)) {
             return new NotEqualRule( $new_operand->getField(), $new_operand->getValue(), $this->options );
-        }
-        elseif ($new_operand instanceof InRule && ! $this->getOption('not_in.normalization', $contextual_options)) {
+        } elseif ($new_operand instanceof InRule && ! $this->getOption('not_in.normalization', $contextual_options)) {
             return new NotInRule( $new_operand->getField(), $new_operand->getPossibilities(), $this->options );
         }
 
         try {
             // Don't use addOperand here to allow inheritance for optimizations (e.g. NotInRule)
             $out = $this->setOperands( $new_operands );
-        }
-        catch (\LogicException $e) {
+        } catch (\LogicException $e) {
             $out = new NotRule( $new_operand );
         }
 

src/Rule/AboveOrEqualRule.php

Spacing +12 added lines, -12 removed lines

@@ -18,9 +18,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, $minimum, array $options=[])
+    public function __construct($field, $minimum, array $options = [])
     {
-        if ( ! empty($options)) {
+        if (!empty($options)) {
             $this->setOptions($options);
         }
 
@@ -63,7 +63,7 @@ 
     /**
      * @return bool
      */
-    public function isNormalizationAllowed(array $contextual_options=[])
+    public function isNormalizationAllowed(array $contextual_options = [])
     {
         return $this->getOption('above_or_equal.normalization', $contextual_options);
     }
@@ -73,7 +73,7 @@ 
      */
     public function getOperands()
     {
-        if ( ! empty($this->cache['operands'])) {
+        if (!empty($this->cache['operands'])) {
             return $this->cache['operands'];
         }
 
@@ -105,9 +105,9 @@ 
             }
         }
 
-        if (   2 != count($operands)
-            || ! isset($equalRuleValue)
-            || ! isset($aboveRuleValue)
+        if (2 != count($operands)
+            || !isset($equalRuleValue)
+            || !isset($aboveRuleValue)
             || $aboveRuleValue != $equalRuleValue
             || $aboveRuleField != $equalRuleField
         ) {
@@ -136,14 +136,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;
             }
         }
 
@@ -162,7 +162,7 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         if (isset($this->cache['string'])) {
             return $this->cache['string'];
@@ -170,7 +170,7 @@ 
 
         $operator = self::operator;
 
-        return $this->cache['string'] = "['{$this->getField()}', '$operator', " . var_export($this->getValues(), true). "]";
+        return $this->cache['string'] = "['{$this->getField()}', '$operator', ".var_export($this->getValues(), true)."]";
     }
 
     /**/