jclaveau / php-logical-filter

src/Rule/NotRule.php

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);
 
@@ -46,7 +46,7 @@ 
      */
     public function negateOperand(array $current_simplification_options)
     {
-        if ( ! $this->isNormalizationAllowed($current_simplification_options)) {
+        if (!$this->isNormalizationAllowed($current_simplification_options)) {
             return $this;
         }
 
@@ -80,11 +80,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());
             }
         }
 
@@ -119,13 +119,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()))
                     );
                 }
             }
@@ -133,15 +133,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(
@@ -159,7 +159,7 @@ 
                         [$sub_operand->copy()],
                         $current_simplification_options
                     );
-                    $new_rule->addOperand( $negation );
+                    $new_rule->addOperand($negation);
                 }
             }
             // $new_rule->dump(!true);
@@ -169,9 +169,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'
             );
         }
@@ -188,11 +188,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);
 
         // not implemented
 
@@ -206,12 +206,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;
@@ -222,19 +222,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'];
         }
 
@@ -244,7 +244,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 {
@@ -254,10 +254,10 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         $operator = self::operator;
-        if ( ! $this->operands) {
+        if (!$this->operands) {
             return "['{$operator}']";
         }
 
@@ -266,7 +266,7 @@ 
 
         $out = "['{$operator}',"
             . $line_break
-            . ($indent_unit ? : ' ')
+            . ($indent_unit ?: ' ')
             . str_replace($line_break, $line_break.$indent_unit, $this->getOperandAt(0)->toString($options))
             . ','
             . $line_break
@@ -304,21 +304,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();
@@ -329,11 +329,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;
     }
 
     /**/