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|null
      */
     public function negateOperand(array $current_simplification_options)
     {
@@ -184,7 +184,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)
     {
@@ -284,6 +284,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 +34 added lines, -34 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;
         }
 
@@ -84,11 +84,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());
         }
         elseif ($operand instanceof AndRule) {
             // @see https://github.com/jclaveau/php-logical-filter/issues/40
@@ -121,13 +121,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()))
                     );
                 }
             }
@@ -135,15 +135,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(
@@ -161,14 +161,14 @@ 
                         [$sub_operand->copy()],
                         $current_simplification_options
                     );
-                    $new_rule->addOperand( $negation );
+                    $new_rule->addOperand($negation);
                 }
             }
             // $new_rule->dump(!true);
         }
         else {
             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);
 
         foreach ($this->operands as $id => $operand) {
             if ($operand instanceof AbstractOperationRule) {
@@ -210,12 +210,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;
@@ -226,19 +226,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'];
         }
 
@@ -248,7 +248,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 {
@@ -258,10 +258,10 @@ 
 
     /**
      */
-    public function toString(array $options=[])
+    public function toString(array $options = [])
     {
         $operator = self::operator;
-        if ( ! $this->operands) {
+        if (!$this->operands) {
             return "['{$operator}']";
         }
 
@@ -270,7 +270,7 @@ 
 
         $out = "['{$operator}',"
             . $line_break
-            . ($indent_unit ? : ' ')
+            . ($indent_unit ?: ' ')
             . str_replace($line_break, $line_break.$indent_unit, $this->getOperandAt(0)->toString($options))
             . ','
             . $line_break
@@ -306,21 +306,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();
@@ -331,11 +331,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;
     }
 
     /**/

src/Rule/AbstractRule.php

Indentation +4 added lines, -4 removed lines

@@ -180,7 +180,7 @@ 
         }
         else {
             throw new \InvalidArgumentException(
-                 "'mode' option must belong to ['string', 'export', 'dump'] "
+                    "'mode' option must belong to ['string', 'export', 'dump'] "
                 ."instead of " . var_export($mode, true)
             );
         }
@@ -273,9 +273,9 @@ 
         }
 
         return hash('md4', serialize( $this->toArray(['semantic' => true]) ))  // faster but longer
-              .'-'
-              .hash('md4', serialize( $this->options ))
-              ;
+                .'-'
+                .hash('md4', serialize( $this->options ))
+                ;
     }
 
     /**

Spacing +23 added lines, -23 removed lines

@@ -33,9 +33,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;
@@ -46,8 +46,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;
@@ -66,16 +66,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);
     }
 
     /**
@@ -92,7 +92,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."
@@ -121,7 +121,7 @@ 
      *
      * @return $this
      */
-    final public function dump($exit=false, array $options=[])
+    final public function dump($exit = false, array $options = [])
     {
         $default_options = [
             'callstack_depth' => 2,
@@ -129,18 +129,18 @@ 
             // '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'])) {
+            if (!isset($options['indent_unit'])) {
                 $options['indent_unit'] = "    ";
             }
 
@@ -158,10 +158,10 @@ 
             }
         }
         elseif ('xdebug' == $mode) {
-            if ( ! function_exists('xdebug_is_enabled')) {
+            if (!function_exists('xdebug_is_enabled')) {
                 throw new \RuntimeException("Xdebug is not installed");
             }
-            if ( ! xdebug_is_enabled()) {
+            if (!xdebug_is_enabled()) {
                 throw new \RuntimeException("Xdebug is disabled");
             }
 
@@ -181,7 +181,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";
@@ -236,12 +236,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;
 
@@ -272,9 +272,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))
               ;
     }
 
@@ -306,7 +306,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]);
                 }
             }