jclaveau / php-logical-filter

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 ($root_OrRule !== null) {
-            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 ($root_OrRule !== null) {
-            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 ($is_valid === false) {

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 ($matching_case === false) {
+            } elseif ($matching_case === false) {
                 // No case match the rule
                 $this->onRowMismatches($row_to_filter, $row_index, $tree_to_filter, $matching_case, $options);
-            }
-            elseif ($matching_case === null) {
+            } elseif ($matching_case === null) {
                 // 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 ($is_valid === true) {
+                    } elseif ($is_valid === true) {
                         // 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 ($case_is_good === false) {
+                } elseif ($case_is_good === false) {
                     $matching_case = false;
-                }
-                elseif ($case_is_good === null) {
+                } elseif ($case_is_good === null) {
                     // row out of scope
                 }
             }

src/Filterer/RuleFilterer.php

Indentation +3 added lines, -3 removed lines

@@ -191,9 +191,9 @@
         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)
+                    . ' ||  '. $value_to_compare . ' => ' . var_export($out, true)
+                    . "\n" . get_class($rule)
+                    . "\n" . var_export($options, true)
             );
             // $rule->dump();
         }

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 ($field === self::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 ($field === self::value) {
             $description = $rule->toArray();
 
-            if (    count($description) === 3
+            if (count($description) === 3
                 && 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 ($field === self::children) {
-            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 ($operator === NotEqualRule::operator) {
             if ($value === null) {
-                $out = ! is_null($value_to_compare);
+                $out = !is_null($value_to_compare);
             }
             else {
                 $out = $value != $value_to_compare;
             }
         }
         elseif ($operator === NotInRule::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 ($field === self::operator) {
+        } elseif ($field === self::operator) {
             $value_to_compare = $rule::operator;
-        }
-        elseif ($field === self::value) {
+        } elseif ($field === self::value) {
             $description = $rule->toArray();
 
             if (    count($description) === 3
                 && 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 ($field === self::description) {
+        } elseif ($field === self::description) {
             $value_to_compare = $rule->toArray();
-        }
-        elseif ($field === self::depth) {
+        } elseif ($field === self::depth) {
             // original $depth is lost once the filter is simplified
             throw new \InvalidArgumentException('Depth rule uppport not implemented');
-        }
-        elseif ($field === self::path) {
+        } elseif ($field === self::path) {
             // TODO the description of its parents
             throw new \InvalidArgumentException('Path rule uppport not implemented');
-        }
-        elseif ($field === self::children) {
+        } elseif ($field === self::children) {
             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 ($operator === EqualRule::operator) {
             if ($value === null) {
                 $out = is_null($value_to_compare);
-            }
-            else {
+            } else {
                 // TODO support strict comparisons
                 $out = $value_to_compare == $value;
             }
-        }
-        elseif ($operator === InRule::operator) {
+        } elseif ($operator === InRule::operator) {
             $out = in_array($value_to_compare, $value);
-        }
-        elseif ($operator === BelowRule::operator) {
+        } elseif ($operator === BelowRule::operator) {
             $out = $value_to_compare < $value;
-        }
-        elseif ($operator === AboveRule::operator) {
+        } elseif ($operator === AboveRule::operator) {
             $out = $value_to_compare > $value;
-        }
-        elseif ($operator === RegexpRule::operator) {
+        } elseif ($operator === RegexpRule::operator) {
             // TODO support optionnal parameters
             $out = preg_match($value, $value_to_compare);
             if ($out === false) {
@@ -170,19 +156,15 @@ 
                 );
             }
             $out = (bool) $out;
-        }
-        elseif ($operator === NotEqualRule::operator) {
+        } elseif ($operator === NotEqualRule::operator) {
             if ($value === null) {
                 $out = ! is_null($value_to_compare);
-            }
-            else {
+            } else {
                 $out = $value != $value_to_compare;
             }
-        }
-        elseif ($operator === NotInRule::operator) {
+        } elseif ($operator === NotInRule::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 ($operator === EqualRule::operator) {
-            if ( ! isset($value_to_validate)) {
+            if (!isset($value_to_validate)) {
                 // ['field', '=', null] <=> isset($row['field'])
                 // [row, '=', null] <=> $row !== null
                 $result = $value === null;
@@ -49,7 +49,7 @@ 
             }
         }
         elseif ($operator === InRule::operator) {
-            if ( ! isset($value_to_validate)) {
+            if (!isset($value_to_validate)) {
                 $result = false;
             }
             else {
@@ -57,7 +57,7 @@ 
             }
         }
         elseif ($operator === BelowRule::operator) {
-            if ( ! isset($value_to_validate)) {
+            if (!isset($value_to_validate)) {
                 $result = false;
             }
             else {
@@ -65,7 +65,7 @@ 
             }
         }
         elseif ($operator === AboveRule::operator) {
-            if ( ! isset($value_to_validate)) {
+            if (!isset($value_to_validate)) {
                 $result = false;
             }
             else {
@@ -81,16 +81,16 @@ 
             }
         }
         elseif ($operator === NotInRule::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 = $value === null;
-            }
-            else {
+            } else {
                 // TODO support strict comparisons
                 $result = $value_to_validate == $value;
             }
-        }
-        elseif ($operator === InRule::operator) {
+        } elseif ($operator === InRule::operator) {
             if ( ! isset($value_to_validate)) {
                 $result = false;
-            }
-            else {
+            } else {
                 $result = in_array($value_to_validate, $value);
             }
-        }
-        elseif ($operator === BelowRule::operator) {
+        } elseif ($operator === BelowRule::operator) {
             if ( ! isset($value_to_validate)) {
                 $result = false;
-            }
-            else {
+            } else {
                 $result = $value_to_validate < $value;
             }
-        }
-        elseif ($operator === AboveRule::operator) {
+        } elseif ($operator === AboveRule::operator) {
             if ( ! isset($value_to_validate)) {
                 $result = false;
-            }
-            else {
+            } else {
                 $result = $value_to_validate > $value;
             }
-        }
-        elseif ($operator === NotEqualRule::operator) {
+        } elseif ($operator === NotEqualRule::operator) {
             if ($value === null) {
                 $result = isset($value_to_validate);
-            }
-            else {
+            } else {
                 $result = $value_to_validate != $value;
             }
-        }
-        elseif ($operator === NotInRule::operator) {
+        } elseif ($operator === NotInRule::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
             );