jclaveau / php-logical-filter

src/Rule/NotRule.php

Doc Comments +3 added lines, -2 removed lines

@@ -41,7 +41,7 @@ 
      * @todo use get_class instead of instanceof to avoid order issue
      *       in the conditions.
      *
-     * @return array
+     * @return AbstractRule
      */
     public function negateOperand(array $current_simplification_options)
     {
@@ -186,7 +186,7 @@ 
      * @todo rename as RootifyDisjunjctions?
      * @todo return $this (implements a Rule monad?)
      *
-     * @return OrRule copied operands with one OR at its root
+     * @return NotRule copied operands with one OR at its root
      */
     public function rootifyDisjunctions($simplification_options)
     {
@@ -286,6 +286,7 @@ 
      * This method is meant to be used during simplification that would
      * need to change the class of the current instance by a normal one.
      *
+     * @param AbstractRule[] $new_operands
      * @return OrRule The current instance (of or or subclass) or a new OrRule
      */
     public function setOperandsOrReplaceByOperation($new_operands, array $contextual_options)

Spacing +35 added lines, -35 removed lines

@@ -12,9 +12,9 @@ 
 
     /**
      */
-    public function __construct( AbstractRule $operand=null, array $options=[] )
+    public function __construct(AbstractRule $operand = null, array $options = [])
     {
-        if ( ! empty($options)) {
+        if (!empty($options)) {
             $this->setOptions($options);
         }
 
@@ -27,7 +27,7 @@ 
 
     /**
      */
-    public function isNormalizationAllowed(array $current_simplification_options=[])
+    public function isNormalizationAllowed(array $current_simplification_options = [])
     {
         $operand = $this->getOperandAt(0);
 
@@ -45,7 +45,7 @@ 
      */
     public function negateOperand(array $current_simplification_options)
     {
-        if ( ! $this->isNormalizationAllowed($current_simplification_options)) {
+        if (!$this->isNormalizationAllowed($current_simplification_options)) {
             return $this;
         }
 
@@ -79,11 +79,11 @@ 
                     ]);
                 }
                 else {
-                    $new_rule = new NotEqualRule( $field, $operand->getValue() );
+                    $new_rule = new NotEqualRule($field, $operand->getValue());
                 }
             }
             elseif ($operand instanceof NotEqualRule) {
-                $new_rule = new EqualRule( $field, $operand->getValue() );
+                $new_rule = new EqualRule($field, $operand->getValue());
             }
         }
 
@@ -118,13 +118,13 @@ 
 
                 $tmp = [];
                 foreach ($current_operand_possibilities->getOperands() as $current_operand_possibility) {
-                    $tmp[] = $current_operand_possibility->addOperand( $next_operand->copy() );
+                    $tmp[] = $current_operand_possibility->addOperand($next_operand->copy());
                 }
                 $current_operand_possibilities->setOperands($tmp);
 
                 foreach ($next_operand_possibilities->getOperands() as $next_operand_possibility) {
                     $current_operand_possibilities->addOperand(
-                        $next_operand_possibility->addOperand( new NotRule($next_operand->copy()) )
+                        $next_operand_possibility->addOperand(new NotRule($next_operand->copy()))
                     );
                 }
             }
@@ -132,15 +132,15 @@ 
             // We remove the only possibility where no rule is negated
             $combinations = $current_operand_possibilities->getOperands();
             array_shift($combinations); // The first rule contains no negation
-            $new_rule->setOperands( $combinations )
+            $new_rule->setOperands($combinations)
                 // ->dump(true)
                 ;
         }
         elseif ($operand instanceof OrRule) {
 
             // $operand->dump(true);
-            if (     $operand instanceof InRule
-                && ! $operand->isNormalizationAllowed($current_simplification_options)
+            if ($operand instanceof InRule
+                && !$operand->isNormalizationAllowed($current_simplification_options)
             ) {
                 // ['not', ['field', 'in', [2, 3]]] <=> ['field', '!in', [2, 3]]
                 $new_rule = new NotInRule(
@@ -158,7 +158,7 @@ 
                         [$sub_operand->copy()],
                         $current_simplification_options
                     );
-                    $new_rule->addOperand( $negation );
+                    $new_rule->addOperand($negation);
                 }
             }
             // $new_rule->dump(!true);
@@ -168,9 +168,9 @@ 
             $new_rule = $operand->getOperandAt(0);
         }
 
-        if ( ! isset($new_rule)) {
+        if (!isset($new_rule)) {
             throw new \LogicException(
-                'Removing NotRule(' . var_export($operand, true) . ') '
+                'Removing NotRule('.var_export($operand, true).') '
                 . ' not implemented'
             );
         }
@@ -190,11 +190,11 @@ 
      */
     public function rootifyDisjunctions($simplification_options)
     {
-        if ( ! $this->isNormalizationAllowed($simplification_options)) {
+        if (!$this->isNormalizationAllowed($simplification_options)) {
             return $this;
         }
 
-        $this->moveSimplificationStepForward( self::rootify_disjunctions, $simplification_options );
+        $this->moveSimplificationStepForward(self::rootify_disjunctions, $simplification_options);
 
         foreach ($this->operands as $id => $operand) {
             if ($operand instanceof AbstractOperationRule) {
@@ -212,12 +212,12 @@ 
      */
     public function unifyAtomicOperands($simplification_strategy_step = false, array $contextual_options)
     {
-        if ( ! $this->isNormalizationAllowed($contextual_options)) {
+        if (!$this->isNormalizationAllowed($contextual_options)) {
             return $this;
         }
 
         if ($simplification_strategy_step) {
-            $this->moveSimplificationStepForward( self::unify_atomic_operands, $contextual_options );
+            $this->moveSimplificationStepForward(self::unify_atomic_operands, $contextual_options);
         }
 
         return $this;
@@ -228,19 +228,19 @@ 
      *
      * @return array
      */
-    public function toArray(array $options=[])
+    public function toArray(array $options = [])
     {
         $default_options = [
             'show_instance' => false,
             'semantic'      => 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;
             }
         }
 
-        if ( ! $options['show_instance'] && isset($this->cache['array'])) {
+        if (!$options['show_instance'] && isset($this->cache['array'])) {
             return $this->cache['array'];
         }
 
@@ -250,7 +250,7 @@ 
         ];
 
         // TODO make a dedicated cache entry for semantic array?
-        if ( ! $options['show_instance'] && ! $options['semantic']) {
+        if (!$options['show_instance'] && !$options['semantic']) {
             return $this->cache['array'] = $array;
         }
         else {
@@ -260,10 +260,10 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         $operator = self::operator;
-        if ( ! $this->operands) {
+        if (!$this->operands) {
             return "['{$operator}']";
         }
 
@@ -272,7 +272,7 @@ 
 
         $out = "['{$operator}',"
             . $line_break
-            . ($indent_unit ? : ' ')
+            . ($indent_unit ?: ' ')
             . str_replace($line_break, $line_break.$indent_unit, $this->getOperandAt(0)->toString($options))
             . ','
             . $line_break
@@ -308,21 +308,21 @@ 
 
         if ($new_operand instanceof NotRule) {
             $operands = $new_operand->getOperands();
-            return reset( $operands );
+            return reset($operands);
         }
-        elseif ($new_operand instanceof EqualRule && ! $this->getOption('not_equal.normalization', $contextual_options)) {
-            return new NotEqualRule( $new_operand->getField(), $new_operand->getValue(), $this->options );
+        elseif ($new_operand instanceof EqualRule && !$this->getOption('not_equal.normalization', $contextual_options)) {
+            return new NotEqualRule($new_operand->getField(), $new_operand->getValue(), $this->options);
         }
-        elseif ($new_operand instanceof InRule && ! $this->getOption('not_in.normalization', $contextual_options)) {
-            return new NotInRule( $new_operand->getField(), $new_operand->getPossibilities(), $this->options );
+        elseif ($new_operand instanceof InRule && !$this->getOption('not_in.normalization', $contextual_options)) {
+            return new NotInRule($new_operand->getField(), $new_operand->getPossibilities(), $this->options);
         }
 
         try {
             // Don't use addOperand here to allow inheritance for optimizations (e.g. NotInRule)
-            $out = $this->setOperands( $new_operands );
+            $out = $this->setOperands($new_operands);
         }
         catch (\LogicException $e) {
-            $out = new NotRule( $new_operand );
+            $out = new NotRule($new_operand);
         }
 
         // $out->dump();
@@ -333,11 +333,11 @@ 
     /**
      *
      */
-    public function hasSolution(array $contextual_options=[])
+    public function hasSolution(array $contextual_options = [])
     {
         $operand = $this->getOperandAt(0);
 
-        return $operand instanceof AbstractAtomicRule ? ! $operand->hasSolution($contextual_options) : true;
+        return $operand instanceof AbstractAtomicRule ? !$operand->hasSolution($contextual_options) : true;
     }
 
     /**/

Braces +12 added lines, -24 removed lines

@@ -59,30 +59,25 @@ 
                     new BelowRule($field, $operand->getMinimum()),
                     new EqualRule($field, $operand->getMinimum()),
                 ]);
-            }
-            elseif ($operand instanceof BelowRule) {
+            } elseif ($operand instanceof BelowRule) {
                 // ! (v >  a) : v <= a : (v < a || a = v)
                 $new_rule = new OrRule([
                     new AboveRule($field, $operand->getMaximum()),
                     new EqualRule($field, $operand->getMaximum()),
                 ]);
-            }
-            elseif ($operand instanceof EqualRule && null === $operand->getValue()) {
+            } elseif ($operand instanceof EqualRule && null === $operand->getValue()) {
                 $new_rule = new NotEqualRule($field, null);
-            }
-            elseif ($operand instanceof EqualRule) {
+            } elseif ($operand instanceof EqualRule) {
                 // ! (v =  a) : (v < a) || (v > a)
                 if ($this->getOption('not_equal.normalization', $current_simplification_options)) {
                     $new_rule = new OrRule([
                         new AboveRule($field, $operand->getValue()),
                         new BelowRule($field, $operand->getValue()),
                     ]);
-                }
-                else {
+                } else {
                     $new_rule = new NotEqualRule( $field, $operand->getValue() );
                 }
-            }
-            elseif ($operand instanceof NotEqualRule) {
+            } elseif ($operand instanceof NotEqualRule) {
                 $new_rule = new EqualRule( $field, $operand->getValue() );
             }
         }
@@ -135,8 +130,7 @@ 
             $new_rule->setOperands( $combinations )
                 // ->dump(true)
                 ;
-        }
-        elseif ($operand instanceof OrRule) {
+        } elseif ($operand instanceof OrRule) {
 
             // $operand->dump(true);
             if (     $operand instanceof InRule
@@ -147,8 +141,7 @@ 
                     $operand->getField(),
                     $operand->getPossibilities()
                 );
-            }
-            else {
+            } else {
                 // ! (A || B) : !A && !B
                 // ! (A || B || C || D) : !A && !B && !C && !D
                 $new_rule = new AndRule;
@@ -162,8 +155,7 @@ 
                 }
             }
             // $new_rule->dump(!true);
-        }
-        elseif ($operand instanceof NotRule) {
+        } elseif ($operand instanceof NotRule) {
             // ! (  !  a) : a
             $new_rule = $operand->getOperandAt(0);
         }
@@ -252,8 +244,7 @@ 
         // TODO make a dedicated cache entry for semantic array?
         if ( ! $options['show_instance'] && ! $options['semantic']) {
             return $this->cache['array'] = $array;
-        }
-        else {
+        } else {
             return $array;
         }
     }
@@ -309,19 +300,16 @@ 
         if ($new_operand instanceof NotRule) {
             $operands = $new_operand->getOperands();
             return reset( $operands );
-        }
-        elseif ($new_operand instanceof EqualRule && ! $this->getOption('not_equal.normalization', $contextual_options)) {
+        } elseif ($new_operand instanceof EqualRule && ! $this->getOption('not_equal.normalization', $contextual_options)) {
             return new NotEqualRule( $new_operand->getField(), $new_operand->getValue(), $this->options );
-        }
-        elseif ($new_operand instanceof InRule && ! $this->getOption('not_in.normalization', $contextual_options)) {
+        } elseif ($new_operand instanceof InRule && ! $this->getOption('not_in.normalization', $contextual_options)) {
             return new NotInRule( $new_operand->getField(), $new_operand->getPossibilities(), $this->options );
         }
 
         try {
             // Don't use addOperand here to allow inheritance for optimizations (e.g. NotInRule)
             $out = $this->setOperands( $new_operands );
-        }
-        catch (\LogicException $e) {
+        } catch (\LogicException $e) {
             $out = new NotRule( $new_operand );
         }