jclaveau / php-logical-filter

src/LogicalFilter.php

Doc Comments +6 added lines, -8 removed lines

@@ -535,7 +535,7 @@ 
      *
      * This helpes to ease the result of simplify()
      *
-     * @return OrRule
+     * @return LogicalFilter
      */
     public function addMinimalCase()
     {
@@ -590,7 +590,7 @@ 
      *
      * @param $debug Provides a source oriented dump.
      *
-     * @return array A description of the rules.
+     * @return string A description of the rules.
      */
     public function toString(array $options=[])
     {
@@ -668,7 +668,7 @@ 
      * @param  array|callable Associative array of renamings or callable
      *                        that would rename the fields.
      *
-     * @return string $this
+     * @return LogicalFilter $this
      */
     public function removeRules($filter)
     {
@@ -711,8 +711,8 @@ 
      * @param  array|callable Associative array of renamings or callable
      *                        that would rename the fields.
      *
-     * @return array The rules matching the filter
-     * @return array $options debug | leaves_only | clean_empty_branches
+     * @return LogicalFilter The rules matching the filter
+     * @return LogicalFilter $options debug | leaves_only | clean_empty_branches
      *
      *
      * @todo Merge with rules
@@ -927,7 +927,6 @@ 
     }
 
     /**
-     * @param bool  $exit=false
      * @param array $options    + callstack_depth=2 The level of the caller to dump
      *                          + mode='string' in 'export' | 'dump' | 'string'
      *
@@ -1022,10 +1021,9 @@ 
      * Applies the current instance to a value (and its index optionnally).
      *
      * @param  mixed                  $value_to_check
-     * @param  scalar                 $index
      * @param  Filterer|callable|null $filterer
      *
-     * @return AbstractRule|false|true + False if the filter doesn't validates
+     * @return boolean + False if the filter doesn't validates
      *                                 + 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.
      */

Spacing +73 added lines, -73 removed lines

@@ -51,7 +51,7 @@ 
      *
      * @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();
@@ -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();
         }
 
@@ -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 {
@@ -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,7 +352,7 @@ 
 
             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'];
@@ -363,7 +363,7 @@ 
                         );
                     }
 
-                    unset($operands_descriptions[ $i ]);
+                    unset($operands_descriptions[$i]);
                 }
             }
 
@@ -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)
                 ;
         }
@@ -559,9 +559,9 @@ 
      *
      * @return bool
      */
-    public function hasSolution($save_simplification=true)
+    public function hasSolution($save_simplification = true)
     {
-        if (! $this->rules) {
+        if ( ! $this->rules) {
             return true;
         }
 
@@ -580,7 +580,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;
     }
@@ -592,7 +592,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;
     }
@@ -630,7 +630,7 @@ 
      * @param  mixed $row
      * @return bool
      */
-    public function __invoke($row, $key=null)
+    public function __invoke($row, $key = null)
     {
         return $this->validates($row, $key);
     }
@@ -680,8 +680,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 "
@@ -717,7 +717,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'];
 
@@ -725,7 +725,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);
@@ -765,13 +765,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 [];
         }
 
@@ -785,7 +785,7 @@ 
                     $key,
                     array $siblings
                 ) use (&$out) {
-                    if (   ! $matching_rule instanceof AndRule
+                    if ( ! $matching_rule instanceof AndRule
                         && ! $matching_rule instanceof OrRule
                         && ! $matching_rule instanceof NotRule
                     ) {
@@ -826,13 +826,13 @@ 
      *
      * @return array          The rules matching the filter
      */
-    public function onEachRule($filter=[], $options)
+    public function onEachRule($filter = [], $options)
     {
         $filter = (new LogicalFilter($filter, new RuleFilterer))
         // ->dump()
         ;
 
-        if (! $this->rules) {
+        if ( ! $this->rules) {
             return [];
         }
 
@@ -865,7 +865,7 @@ 
     {
         $this->simplify()->addMinimalCase();
 
-        if (! $this->rules) {
+        if ( ! $this->rules) {
             return $this;
         }
 
@@ -909,7 +909,7 @@ 
      *
      * @return LogicalFilter
      */
-    public function saveAs( &$variable)
+    public function saveAs(&$variable)
     {
         return $variable = $this;
     }
@@ -920,7 +920,7 @@ 
      *
      * @return LogicalFilter
      */
-    public function saveCopyAs( &$copied_variable)
+    public function saveCopyAs(&$copied_variable)
     {
         $copied_variable = $this->copy();
         return $this;
@@ -933,15 +933,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);
@@ -952,24 +952,24 @@ 
         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);
@@ -994,15 +994,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)
@@ -1010,8 +1010,8 @@ 
         }
 
         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);
@@ -1029,15 +1029,15 @@ 
      *                                 + 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)

src/Filterer/Filterer.php

Spacing +23 added lines, -23 removed lines

@@ -47,11 +47,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;
@@ -73,7 +73,7 @@ 
      */
     public function onRowMismatches(&$row, $key, &$rows, $matching_case, $options)
     {
-        if (   ! $this->custom_actions
+        if ( ! $this->custom_actions
             && ! isset($options[self::on_row_mismatches])
             && ! isset($options[self::on_row_matches])
         ) {
@@ -82,11 +82,11 @@ 
             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;
@@ -123,13 +123,13 @@ 
      * @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 = [])
     {
-        if (! $filter->hasSolution()) {
+        if ( ! $filter->hasSolution()) {
             return null;
         }
 
-        if (! isset($options['recurse'])) {
+        if ( ! isset($options['recurse'])) {
             $options['recurse'] = 'before';
         }
         elseif ( ! in_array($options['recurse'], ['before', 'after', null])) {
@@ -141,16 +141,16 @@ 
         }
 
         return $this->foreachRow(
-            !$filter->getRules() ? [] : $filter->addMinimalCase()->getRules()->getOperands(),
+            ! $filter->getRules() ? [] : $filter->addMinimalCase()->getRules()->getOperands(),
             $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) {
@@ -209,23 +209,23 @@ 
      *
      * @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 = [])
     {
-        if (! $filter->hasSolution()) {
+        if ( ! $filter->hasSolution()) {
             return null;
         }
 
         return $this->applyOnRow(
-            !$filter->getRules() ? [] : $filter->addMinimalCase()->getRules()->getOperands(),
+            ! $filter->getRules() ? [] : $filter->addMinimalCase()->getRules()->getOperands(),
             $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 = [];
 
@@ -261,8 +261,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(
@@ -275,7 +275,7 @@ 
                             $options
                         );
 
-                        $operands_validation_row_cache[ $cache_key ] = $is_valid;
+                        $operands_validation_row_cache[$cache_key] = $is_valid;
                     }
 
                     if (false === $is_valid) {

src/Rule/AbstractRule.php

Spacing +22 added lines, -22 removed lines

@@ -35,9 +35,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;
@@ -50,8 +50,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;
@@ -70,16 +70,16 @@ 
      *
      * @return AbstractRule
      */
-    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);
     }
 
     /**
@@ -96,7 +96,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."
@@ -125,7 +125,7 @@ 
      *
      * @return $this
      */
-    final public function dump($exit=false, array $options=[])
+    final public function dump($exit = false, array $options = [])
     {
         $default_options = [
             'callstack_depth' => 2,
@@ -133,16 +133,16 @@ 
             // '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'])) {
                 $options['indent_unit'] = "    ";
@@ -185,7 +185,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";
@@ -240,12 +240,12 @@ 
     /**
      * @return string
      */
-    abstract public function toString(array $options=[]);
+    abstract public function toString(array $options = []);
 
     /**
      * @return array
      */
-    abstract public function toArray(array $options=[]);
+    abstract public function toArray(array $options = []);
 
     protected $instance_id;
 
@@ -276,9 +276,9 @@ 
             return $this->cache['semantic_id'];
         }
 
-        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))
               ;
     }
 
@@ -316,7 +316,7 @@ 
             $simplification_step_to_keep = null;
         }
 
-        if (   $this instanceof AbstractAtomicRule
+        if ($this instanceof AbstractAtomicRule
             || $this instanceof NotRule
             || $this instanceof InRule
             || ! $this->isNormalizationAllowed([])
@@ -334,7 +334,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]);
                 }
             }
@@ -349,7 +349,7 @@ 
 
         if ($simplification_step_to_keep) {
             foreach ($operands = $ruleTree->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