jclaveau / php-logical-filter

src/Filterer/FiltererInterface.php

Spacing +1 added lines, -1 removed lines

@@ -16,7 +16,7 @@
      * @param LogicalFilter $filter
      * @param Iterable      $data_to_filter
      */
-    public function apply( LogicalFilter $filter, $tree_to_filter, $options=[] );
+    public function apply(LogicalFilter $filter, $tree_to_filter, $options = []);
 
     public function validateRule($field, $operator, $value, $row, array $path, $all_operands, $options);
 

src/Filterer/Filterer.php

Spacing +20 added lines, -20 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])
@@ -154,14 +154,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])
@@ -242,14 +242,14 @@ 
         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 = [];
 
@@ -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 +25 added lines, -38 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;
         }
 
@@ -131,19 +127,18 @@ 
             ;
 
         if ($root_OrRule !== null) {
-            if (!$root_OrRule->hasSolution())
-                return null;
+            if (!$root_OrRule->hasSolution()) {
+                            return null;
+            }
 
             $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 +180,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
             }
@@ -230,12 +223,12 @@ 
             ;
 
         if ($root_OrRule !== null) {
-            if (!$root_OrRule->hasSolution())
-                return null;
+            if (!$root_OrRule->hasSolution()) {
+                            return null;
+            }
 
             $root_cases = $root_OrRule->getOperands();
-        }
-        else {
+        } else {
             $root_cases = [];
         }
 
@@ -255,13 +248,13 @@ 
 
         if (!$root_cases) {
             $matching_case = true;
-        }
-        else {
+        } else {
             $matching_case = null;
             foreach ($root_cases as $and_case_index => $and_case) {
 
-                if (!empty($options['debug']))
-                    var_dump("Case $and_case_index: ".$and_case);
+                if (!empty($options['debug'])) {
+                                    var_dump("Case $and_case_index: ".$and_case);
+                }
 
                 $case_is_good = null;
                 foreach ($and_case->getOperands() as $i => $rule) {
@@ -269,16 +262,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 +281,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 +300,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 +311,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/CustomizableFilterer.php

Spacing +2 added lines, -2 removed lines

@@ -16,7 +16,7 @@ 
 
     /**
      */
-    public function __construct( callable $rule_validator )
+    public function __construct(callable $rule_validator)
     {
         $this->rule_validator = $rule_validator;
     }
@@ -25,7 +25,7 @@ 
      */
     public function validateRule($field, $operator, $value, $row, array $path, $all_operands, $options)
     {
-        return call_user_func_array( $this->rule_validator, get_defined_vars() );
+        return call_user_func_array($this->rule_validator, get_defined_vars());
     }
 
     /**/

src/Filterer/PhpFilterer.php

Indentation +5 added lines, -5 removed lines

@@ -39,8 +39,8 @@ 
 
         if ($operator === EqualRule::operator) {
             if (!isset($value_to_validate)) {
-                 // ['field', '=', null] <=> isset($row['field'])
-                 // [row, '=', null] <=> $row !== null
+                    // ['field', '=', null] <=> isset($row['field'])
+                    // [row, '=', null] <=> $row !== null
                 $result = $value === null;
             }
             else {
@@ -96,9 +96,9 @@ 
 
         // var_dump(
             // "$field, $operator, " . var_export($value, true)
-             // . ' vs ' . var_export($value_to_validate, true) . ' => ' . var_export($result, true)
-             // . "\n\n"
-             // . var_export($row, true)
+                // . ' vs ' . var_export($value_to_validate, true) . ' => ' . var_export($result, true)
+                // . "\n\n"
+                // . var_export($row, true)
         // );
         // exit;
         return $result;

Spacing +5 added lines, -5 removed lines

@@ -22,19 +22,19 @@ 
 {
     /**
      */
-    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])) {
             $value_to_validate = null;
         }
         else {
-            $value_to_validate = $row[ $field ];
+            $value_to_validate = $row[$field];
         }
 
         if ($operator === EqualRule::operator) {
@@ -90,7 +90,7 @@ 
         }
         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
             );

src/Filterer/RuleFilterer.php

Indentation +3 added lines, -3 removed lines

@@ -189,9 +189,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 +17 added lines, -17 removed lines

@@ -32,7 +32,7 @@ 
  */
 class RuleFilterer extends Filterer
 {
-    const this       = 'instance';
+    const this = 'instance';
     const field       = 'field';
     const operator    = 'operator';
     const value       = 'value';
@@ -59,20 +59,20 @@ 
 
     /**
      */
-    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?
     }
 
     /**
      *
      * @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;
@@ -98,9 +98,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 {
@@ -122,7 +122,7 @@ 
         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() );
+            $value_to_compare = count($rule->getOperands());
         }
         else {
             throw new \InvalidArgumentException(
@@ -182,16 +182,16 @@ 
         }
         else {
             throw new \InvalidArgumentException(
-                "Unhandled operator: " . $operator
+                "Unhandled operator: ".$operator
             );
         }
 
         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();
         }
@@ -204,7 +204,7 @@ 
      * @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)
             return $ruleTree_to_filter;
@@ -215,14 +215,14 @@ 
         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 +37 added lines, -47 removed lines

@@ -61,8 +61,10 @@ 
      */
     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?
+        if ($row instanceof AbstractOperationRule) {
+                    return $row->setOperandsOrReplaceByOperation( $filtered_children, [] );
+        }
+        // no simplification options?
     }
 
     /**
@@ -79,52 +81,47 @@ 
         }
 
         if ($field === self::field) {
-            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
+            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
 
             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');
             // $value_to_compare = $depth;
-        }
-        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) {
-            if (!method_exists($rule, 'getOperands'))
-                return null; // The filter cannot be applied to this rule
+        } 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(', ', [
@@ -143,22 +140,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) {
@@ -168,19 +160,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
             );
@@ -206,11 +194,13 @@ 
      */
     public function apply( LogicalFilter $filter, $ruleTree_to_filter, $options=[] )
     {
-        if (!$ruleTree_to_filter)
-            return $ruleTree_to_filter;
+        if (!$ruleTree_to_filter) {
+                    return $ruleTree_to_filter;
+        }
 
-        if ($ruleTree_to_filter instanceof AbstractRule)
-            $ruleTree_to_filter = [$ruleTree_to_filter];
+        if ($ruleTree_to_filter instanceof AbstractRule) {
+                    $ruleTree_to_filter = [$ruleTree_to_filter];
+        }
 
         if (!is_array($ruleTree_to_filter)) {
             throw new \InvalidArgumentException(

src/Converter/ConverterInterface.php

Spacing +1 added lines, -1 removed lines

@@ -34,7 +34,7 @@
     /**
      * @param LogicalFilter $filter
      */
-    public function convert( LogicalFilter $filter );
+    public function convert(LogicalFilter $filter);
 
     /**/
 }

src/Converter/MinimalConverter.php

Indentation +1 added lines, -1 removed lines

@@ -38,7 +38,7 @@
                 foreach ($operandsByOperator as $operator => $operandsOfOperator) {
                     if (count($operandsOfOperator) != 1) {
                         throw new \RuntimeException(
-                             "Once a logical filter is simplified, there MUST be "
+                                "Once a logical filter is simplified, there MUST be "
                             ."no more than one operand by operator instead of for '$field' / '$operator': "
                             .var_export($operandsOfOperator, true)
                         );

Spacing +2 added lines, -2 removed lines

@@ -18,7 +18,7 @@ 
     /**
      * @param LogicalFilter $filter
      */
-    public function convert( LogicalFilter $filter )
+    public function convert(LogicalFilter $filter)
     {
         $rootOr = $filter->simplify(['force_logical_core' => true])->getRules();
 
@@ -44,7 +44,7 @@ 
                         );
                     }
 
-                    $operandsByFields[ $field ][ $operator ] = $operandsOfOperator[0];
+                    $operandsByFields[$field][$operator] = $operandsOfOperator[0];
                 }
             }
 

Braces +6 added lines, -4 removed lines

@@ -23,11 +23,13 @@
         $rootOr = $filter->simplify(['force_logical_core' => true])->getRules();
 
         // TODO remove this once TrueRule implemented https://github.com/jclaveau/php-logical-filter/issues/59
-        if ($rootOr === null)
-            return $this;
+        if ($rootOr === null) {
+                    return $this;
+        }
 
-        if (!$rootOr->hasSolution())
-            return $this;
+        if (!$rootOr->hasSolution()) {
+                    return $this;
+        }
 
         foreach ($rootOr->getOperands() as $andOperand) {
 

src/Converter/CustomizableMinimalConverter.php

Spacing +3 added lines, -3 removed lines

@@ -30,14 +30,14 @@ 
      */
     public function onOpenOr()
     {
-        call_user_func( $this->callbacks[ __FUNCTION__ ] );
+        call_user_func($this->callbacks[__FUNCTION__]);
     }
 
     /**
      */
     public function onCloseOr()
     {
-        call_user_func( $this->callbacks[ __FUNCTION__ ] );
+        call_user_func($this->callbacks[__FUNCTION__]);
     }
 
     /**
@@ -47,7 +47,7 @@ 
     public function onAndPossibility($field, $operator, $operand, array $allOperandsByField)
     {
         call_user_func(
-            $this->callbacks[ __FUNCTION__ ],
+            $this->callbacks[__FUNCTION__],
             $field,
             $operator,
             $operand,

src/Converter/InlineSqlMinimalConverter.php

Spacing +7 added lines, -7 removed lines

@@ -47,12 +47,12 @@ 
     /**
      * @param LogicalFilter $filter
      */
-    public function convert( LogicalFilter $filter )
+    public function convert(LogicalFilter $filter)
     {
         $this->output = [];
         parent::convert($filter);
         return [
-            'sql' => ! $this->output
+            'sql' => !$this->output
                    ? '1' // True
                    : '('.implode(') OR (', $this->output).')',
             'parameters' => $this->parameters,
@@ -71,7 +71,7 @@ 
     public function onCloseOr()
     {
         $last_key = $this->getLastOrOperandKey();
-        $this->output[ $last_key ] = implode(' AND ', $this->output[ $last_key ]);
+        $this->output[$last_key] = implode(' AND ', $this->output[$last_key]);
     }
 
     /**
@@ -100,7 +100,7 @@ 
             $value = $rule->getValue();
         }
         elseif ($rule instanceof RegexpRule) {
-            $value = RegexpRule::php2mariadbPCRE( $rule->getPattern() );
+            $value = RegexpRule::php2mariadbPCRE($rule->getPattern());
         }
         else {
             throw new \InvalidArgumentException(
@@ -124,7 +124,7 @@ 
             foreach ($value as $possibility) {
                 $sql_part[] = $this->addParameter($possibility);
             }
-            $value = '(' . implode(', ', $sql_part) . ')';
+            $value = '('.implode(', ', $sql_part).')';
         }
         elseif ($value === null) {
             $value = "NULL";
@@ -142,7 +142,7 @@ 
         }
         else {
             throw new \InvalidArgumentException(
-                "Unhandled type of value: ".gettype($value). ' | ' .var_export($value, true)
+                "Unhandled type of value: ".gettype($value).' | '.var_export($value, true)
             );
         }
 
@@ -167,7 +167,7 @@ 
     protected function appendToLastOrOperandKey($rule)
     {
         $last_key = $this->getLastOrOperandKey();
-        $this->output[ $last_key ][] = $rule;
+        $this->output[$last_key][] = $rule;
     }
 
     /**/

Braces +21 added lines, -34 removed lines

@@ -31,13 +31,15 @@ 
      */
     public function addParameter($value)
     {
-        if (is_numeric($value))
-            return $value;
+        if (is_numeric($value)) {
+                    return $value;
+        }
 
         $uid = 'param_'.hash('crc32b', serialize($value));
 
-        if (isset($this->parameters[$uid]))
-            return ':'.$uid;
+        if (isset($this->parameters[$uid])) {
+                    return ':'.$uid;
+        }
 
         $this->parameters[$uid] = $value;
 
@@ -82,65 +84,50 @@ 
     {
         if ($rule instanceof EqualRule) {
             $value = $rule->getValue();
-        }
-        elseif ($rule instanceof InRule) {
+        } elseif ($rule instanceof InRule) {
             $value = $rule->getPossibilities();
-        }
-        elseif ($rule instanceof NotInRule) {
+        } elseif ($rule instanceof NotInRule) {
             $operator = 'NOT IN';
             $value = $rule->getPossibilities();
-        }
-        elseif ($rule instanceof AboveRule) {
+        } elseif ($rule instanceof AboveRule) {
             $value = $rule->getMinimum();
-        }
-        elseif ($rule instanceof BelowRule) {
+        } elseif ($rule instanceof BelowRule) {
             $value = $rule->getMaximum();
-        }
-        elseif ($rule instanceof NotEqualRule) {
+        } elseif ($rule instanceof NotEqualRule) {
             $value = $rule->getValue();
-        }
-        elseif ($rule instanceof RegexpRule) {
+        } elseif ($rule instanceof RegexpRule) {
             $value = RegexpRule::php2mariadbPCRE( $rule->getPattern() );
-        }
-        else {
+        } else {
             throw new \InvalidArgumentException(
                 "Unhandled operator '$operator' during SQL query generation"
             );
         }
 
         if (gettype($value) == 'integer') {
-        }
-        elseif (gettype($value) == 'double') {
+        } elseif (gettype($value) == 'double') {
             // TODO disable locale to handle separators
-        }
-        elseif ($value instanceof \DateTime) {
+        } elseif ($value instanceof \DateTime) {
             $value = $value->format('Y-m-d H:i:s');
-        }
-        elseif (gettype($value) == 'string') {
+        } elseif (gettype($value) == 'string') {
             $value = $this->addParameter($value);
-        }
-        elseif (gettype($value) == 'array') {
+        } elseif (gettype($value) == 'array') {
             $sql_part = [];
             foreach ($value as $possibility) {
                 $sql_part[] = $this->addParameter($possibility);
             }
             $value = '(' . implode(', ', $sql_part) . ')';
-        }
-        elseif ($value === null) {
+        } elseif ($value === null) {
             $value = "NULL";
             if ($rule instanceof EqualRule) {
                 $operator = 'IS';
-            }
-            elseif ($rule instanceof NotEqualRule) {
+            } elseif ($rule instanceof NotEqualRule) {
                 $operator = 'IS NOT';
-            }
-            else {
+            } else {
                 throw new \InvalidArgumentException(
                     "NULL is only handled for equality / difference"
                 );
             }
-        }
-        else {
+        } else {
             throw new \InvalidArgumentException(
                 "Unhandled type of value: ".gettype($value). ' | ' .var_export($value, true)
             );