jclaveau / php-logical-filter

src/LogicalFilter.php

Indentation +4 added lines, -4 removed lines

@@ -231,7 +231,7 @@ 
         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 "
+                    "You are trying to add rules to a LogicalFilter which had "
                 ."only contradictory rules that have already been simplified: "
                 .$this->rules
             );
@@ -652,7 +652,7 @@ 
                     unset( $rows[$key] );
                     if ( ! $rows ) {
                         throw new \Exception(
-                             "Removing the only rule $rule from the filter $this"
+                                "Removing the only rule $rule from the filter $this"
                             ."produces a case which has no possible solution due to missing "
                             ."implementation of TrueRule.\n"
                             ."Please see: https://github.com/jclaveau/php-logical-filter/issues/59"
@@ -939,7 +939,7 @@ 
         }
         elseif (!$filterer instanceof Filterer) {
             throw new \InvalidArgumentException(
-                 "The given \$filterer must be null or a callable or a instance "
+                    "The given \$filterer must be null or a callable or a instance "
                 ."of Filterer instead of: ".var_export($filterer, true)
             );
         }
@@ -974,7 +974,7 @@ 
         }
         elseif (!$filterer instanceof Filterer) {
             throw new \InvalidArgumentException(
-                 "The given \$filterer must be null or a callable or a instance "
+                    "The given \$filterer must be null or a callable or a instance "
                 ."of Filterer instead of: ".var_export($filterer, true)
             );
         }

Spacing +70 added lines, -70 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)
@@ -70,7 +70,7 @@ 
             $this->options = $options;
 
         if ($rules)
-            $this->and_( $rules );
+            $this->and_($rules);
     }
 
     /**
@@ -132,7 +132,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
@@ -155,7 +155,7 @@ 
             }
         }
 
-        if (    count($rules_description) == 3
+        if (count($rules_description) == 3
             &&  is_string($rules_description[0])
             &&  is_string($rules_description[1])
         ) {
@@ -171,30 +171,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 ($rules !== null)
-                    $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 (count($rules_description) == 1 && 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 {
@@ -205,7 +205,7 @@ 
                     $fake_root
                 );
 
-                $this->addRule( $fake_root->getOperands()[0], $operation );
+                $this->addRule($fake_root->getOperands()[0], $operation);
             }
         }
         else {
@@ -226,10 +226,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: "
@@ -278,7 +278,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
@@ -287,13 +287,13 @@ 
                 .var_export($rules_composition, true)
             );
         }
-        elseif (    count($rules_composition) == 3
-            &&  !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 (count($rules_composition) == 3
+            &&  !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];
@@ -303,20 +303,20 @@ 
             $rule = AbstractRule::generateSimpleRule(
                 $operand_left, $operation, $operand_right, $this->getOptions()
             );
-            $recursion_position->addOperand( $rule );
+            $recursion_position->addOperand($rule);
         }
         else {
             // operations
-            if (    $rules_composition[0] == NotRule::operator
-                ||  $rules_composition[0] == AbstractRule::findSymbolicOperator( NotRule::operator ) ) {
+            if ($rules_composition[0] == NotRule::operator
+                ||  $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 {
@@ -330,8 +330,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)]);
                 }
             );
 
@@ -346,18 +346,18 @@ 
 
             foreach ($operands_descriptions as $i => $operands_description) {
                 if ($operands_description === false) {
-                    $operands_descriptions[ $i ] = ['and']; // FalseRule hack
+                    $operands_descriptions[$i] = ['and']; // FalseRule hack
                 }
                 elseif ($operands_description === null || $operands_description === true) {
                     $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]);
                 }
             }
 
@@ -375,7 +375,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)
                 );
             }
 
@@ -401,7 +401,7 @@ 
                 }
             }
 
-            $recursion_position->addOperand( $rule );
+            $recursion_position->addOperand($rule);
         }
 
         return $this;
@@ -430,7 +430,7 @@ 
      */
     public function and_()
     {
-        $this->addRules( AndRule::operator, func_get_args());
+        $this->addRules(AndRule::operator, func_get_args());
         return $this;
     }
 
@@ -458,7 +458,7 @@ 
      */
     public function or_()
     {
-        $this->addRules( OrRule::operator, func_get_args());
+        $this->addRules(OrRule::operator, func_get_args());
         return $this;
     }
 
@@ -505,12 +505,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)
                 ;
         }
@@ -531,7 +531,7 @@ 
      *
      * @return bool
      */
-    public function hasSolution($save_simplification=true)
+    public function hasSolution($save_simplification = true)
     {
         if (!$this->rules)
             return true;
@@ -551,7 +551,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;
     }
@@ -563,7 +563,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;
     }
@@ -601,7 +601,7 @@ 
      * @param  mixed $row
      * @return bool
      */
-    public function __invoke($row, $key=null)
+    public function __invoke($row, $key = null)
     {
         return $this->validates($row, $key);
     }
@@ -649,8 +649,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 "
@@ -685,7 +685,7 @@ 
      *
      * @todo Merge with rules
      */
-    public function keepLeafRulesMatching($filter=[], array $options=[])
+    public function keepLeafRulesMatching($filter = [], array $options = [])
     {
         $clean_empty_branches = !isset($options['clean_empty_branches']) || $options['clean_empty_branches'];
 
@@ -693,7 +693,7 @@ 
         // ->dump()
         ;
 
-        $options[ Filterer::leaves_only ] = true;
+        $options[Filterer::leaves_only] = true;
 
         $this->rules = (new RuleFilterer)->apply($filter, $this->rules, $options);
         // $this->rules->dump(true);
@@ -709,7 +709,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) {
                     }
@@ -733,7 +733,7 @@ 
      *
      * @todo Merge with rules
      */
-    public function listLeafRulesMatching($filter=[])
+    public function listLeafRulesMatching($filter = [])
     {
         $filter = (new LogicalFilter($filter, new RuleFilterer))
         // ->dump()
@@ -753,7 +753,7 @@ 
                     array $siblings
                 ) use (&$out) {
 
-                    if (    !$matching_rule instanceof AndRule
+                    if (!$matching_rule instanceof AndRule
                         &&  !$matching_rule instanceof OrRule
                         &&  !$matching_rule instanceof NotRule
                     ) {
@@ -776,7 +776,7 @@ 
      *
      * @todo Make it available on AbstractRule also
      */
-    public function onEachRule($filter=[], $options)
+    public function onEachRule($filter = [], $options)
     {
         $filter = (new LogicalFilter($filter, new RuleFilterer))
         // ->dump()
@@ -806,7 +806,7 @@ 
     {
         $this->simplify(['force_logical_core' => true]);
 
-        if (! $this->rules)
+        if (!$this->rules)
             return $this;
 
         $operands = $this->rules->getOperands();
@@ -849,7 +849,7 @@ 
      *
      * @return LogicalFilter
      */
-    public function saveAs( &$variable )
+    public function saveAs(&$variable)
     {
         return $variable = $this;
     }
@@ -860,7 +860,7 @@ 
      *
      * @return LogicalFilter
      */
-    public function saveCopyAs( &$copied_variable )
+    public function saveCopyAs(&$copied_variable)
     {
         $copied_variable = $this->copy();
         return $this;
@@ -873,15 +873,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);
 
@@ -891,21 +891,21 @@ 
         else {
             // TODO dump a TrueRule
             $bt = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, $callstack_depth);
-            $caller = $bt[ $callstack_depth - 2 ];
+            $caller = $bt[$callstack_depth - 2];
 
             // get line and file from the previous level of the caller
             // TODO go deeper if this case exist?
             if (!isset($caller['file']))
-                $caller['file'] = $bt[ $callstack_depth - 3 ]['file'];
+                $caller['file'] = $bt[$callstack_depth - 3]['file'];
             if (!isset($caller['line']))
-                $caller['line'] = $bt[ $callstack_depth - 3 ]['line'];
+                $caller['line'] = $bt[$callstack_depth - 3]['line'];
 
             try {
-                echo "\n" . $caller['file'] . ':' . $caller['line'] . "\n";
+                echo "\n".$caller['file'].':'.$caller['line']."\n";
                 var_export($this->toArray($options));
             }
             catch (\Exception $e) {
-                echo "\nError while dumping: " . $e->getMessage() . "\n";
+                echo "\nError while dumping: ".$e->getMessage()."\n";
                 var_export($caller);
                 echo "\n\n";
                 var_export($bt);
@@ -929,7 +929,7 @@ 
      *
      * @return mixed The filtered data
      */
-    public function applyOn($data_to_filter, $action_on_matches=null, $filterer=null)
+    public function applyOn($data_to_filter, $action_on_matches = null, $filterer = null)
     {
         if (!$filterer) {
             $filterer = $this->getDefaultFilterer();
@@ -945,11 +945,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);
         }
     }
 
@@ -964,7 +964,7 @@ 
      *                                 + Null if the target has no sens (operation filtered by field for example)
      *                                 + A rule tree containing the first matching case if there is one.
      */
-    public function validates($value_to_check, $key_to_check=null, $filterer=null)
+    public function validates($value_to_check, $key_to_check = null, $filterer = null)
     {
         if (!$filterer) {
             $filterer = $this->getDefaultFilterer();
@@ -979,7 +979,7 @@ 
             );
         }
 
-        return $filterer->hasMatchingCase( $this, $value_to_check, $key_to_check );
+        return $filterer->hasMatchingCase($this, $value_to_check, $key_to_check);
     }
 
     /**/