NotRule::negateOperand() - Code Metrics - jclaveau/php-logical-filter - Measure and Improve Code Quality continuously with Scrutinizer

NotRule::negateOperand() F
last analyzed 2019-08-15 22:31 UTC

↳ Parent: NotRule
Complexity

Conditions	20
Paths	81
Size

Total Lines
136
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	87
CRAP Score	20.0045
Importance

Changes
Metric	Value
cc	20
nc	81
nop	1
dl	0
loc	136
ccs	87
cts	89
cp	0.9775
crap	20.0045
rs	3.3333
c	0
b	0
f	0
How to fix Long Method Complexity

<?php
namespace JClaveau\LogicalFilter\Rule;

/**
 * Logical negation:
 * @see https://en.wikipedia.org/wiki/Negation
 */
class NotRule extends AbstractOperationRule
{
    /** @var string operator */
    const operator = 'not';

    /**
     */
    public function __construct( AbstractRule $operand=null, array $options=[] )
    {
        if ( ! empty($options)) {
            $this->setOptions($options);
        }

        // Negation has only one operand. If more is required, group them
        // into an AndRule
        if ($operand) {
            $this->addOperand($operand);
        }
    }

    /**
     */
    public function isNormalizationAllowed(array $current_simplification_options=[])
    {
        $operand = $this->getOperandAt(0);

        return null !== $operand;
    }

    /**
     * Transforms all composite rules in the tree of operands into
     * atomic rules.
     *
     * @todo use get_class instead of instanceof to avoid order issue
     *       in the conditions.
     *
     * @param  array
     * @return AbstractRule
     */
    public function negateOperand(array $current_simplification_options)
    {
        if ( ! $this->isNormalizationAllowed($current_simplification_options)) {
            return $this;
        }

        $operand = $this->getOperandAt(0);

        if (method_exists($operand, 'getField')) {
            $field = $operand->getField();

            if ($operand instanceof AboveRule) {
                $new_rule = new OrRule([
                    new BelowRule($field, $operand->getLowerLimit()),
                    new EqualRule($field, $operand->getLowerLimit()),
                ]);
            }
            elseif ($operand instanceof BelowRule) {
                // ! (v >  a) : v <= a : (v < a || a = v)
                $new_rule = new OrRule([
                    new AboveRule($field, $operand->getUpperLimit()),
                    new EqualRule($field, $operand->getUpperLimit()),
                ]);
            }
            elseif ($operand instanceof EqualRule && null === $operand->getValue()) {
                $new_rule = new NotEqualRule($field, null);
            }
            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 {
                    $new_rule = new NotEqualRule( $field, $operand->getValue() );
                }
            }
            elseif ($operand instanceof NotEqualRule) {
                $new_rule = new EqualRule( $field, $operand->getValue() );
            }
        }

        if ($operand instanceof AndRule) {
            // @see https://github.com/jclaveau/php-logical-filter/issues/40
            // ! (B && A) : (!B && A) || (B && !A) || (!B && !A)
            // ! (A && B && C) :
            //    (!A && !B && !C)
            // || (!A && B && C) || (!A && !B && C) || (!A && B && !C)
            // || (A && !B && C) || (!A && !B && C) || (A && !B && !C)
            // || (A && B && !C) || (!A && B && !C) || (A && !B && !C)

            // We combine all possibilities of rules and themselves negated
            $new_rule       = new OrRule;
            $child_operands = $operand->getOperands();

            $current_operand               = array_shift($child_operands);
            $current_operand_possibilities = new OrRule([
                new AndRule([
                    $current_operand->copy(),
                ]),
                new AndRule([
                    new NotRule($current_operand->copy()),
                ]),
            ]);

            // for every remaining operand, we duplicate the already made
            // combinations and add on half of them !$next_operand
            // and $next_operand on the other half
            while ($next_operand = array_shift($child_operands)) {
                $next_operand_possibilities = $current_operand_possibilities->copy();

                $tmp = [];
                foreach ($current_operand_possibilities->getOperands() as $current_operand_possibility) {
                    $tmp[] = $current_operand_possibility->addOperand( $next_operand->copy() );
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                }
                $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()) )
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                    );
                }
            }

            // 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 )
                // ->dump(true)
                ;
        }
        elseif ($operand instanceof OrRule) {

            // $operand->dump(true);
            if (     $operand instanceof InRule
                && ! $operand->isNormalizationAllowed($current_simplification_options)
            ) {
                // ['not', ['field', 'in', [2, 3]]] <=> ['field', '!in', [2, 3]]
                $new_rule = new NotInRule(
                    $operand->getField(),
                    $operand->getPossibilities()
                );
            }
            else {
                // ! (A || B) : !A && !B
                // ! (A || B || C || D) : !A && !B && !C && !D
                $new_rule = new AndRule;
                foreach ($operand->getOperands() as $sub_operand) {
                    $negation = new NotRule;
                    $negation = $negation->setOperandsOrReplaceByOperation(
                        [$sub_operand->copy()],
                        $current_simplification_options
                    );
                    $new_rule->addOperand( $negation );
                }
            }
            // $new_rule->dump(!true);
        }
        elseif ($operand instanceof NotRule) {
            // ! (  !  a) : a
            $new_rule = $operand->getOperandAt(0);
        }

        if ( ! isset($new_rule)) {
            throw new \LogicException(
                'Removing NotRule(' . var_export($operand, true) . ') '
                . ' not implemented'
            );
        }

        // $new_rule->dump(!true);

        return $new_rule;
    }

    /**
     * @todo   Todo remove this method while refactoring the Class tree
     *
     * @return NotRule
     */
    public function rootifyDisjunctions($simplification_options)
    {
        if ( ! $this->isNormalizationAllowed($simplification_options)) {
            return $this;
        }

        $this->moveSimplificationStepForward( self::rootify_disjunctions, $simplification_options );

        // not implemented

        return $this;
    }

    /**
     * Not rules can only have one operand.
     *
     * @return $this
     */
    public function unifyAtomicOperands($simplification_strategy_step = false, array $contextual_options)
    {
        if ( ! $this->isNormalizationAllowed($contextual_options)) {
            return $this;
        }

        if ($simplification_strategy_step) {
            $this->moveSimplificationStepForward( self::unify_atomic_operands, $contextual_options );
        }

        return $this;
    }

    /**
     * @param array $options   + show_instance=false Display the operator of the rule or its instance id
     *
     * @return array
     */
    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 ( ! $options['show_instance'] && isset($this->cache['array'])) {
            return $this->cache['array'];
        }

        $array = [
            $options['show_instance'] ? $this->getInstanceId() : self::operator,
            $this->getOperandAt(0) ? $this->getOperandAt(0)->toArray($options) : false,
        ];

        // TODO make a dedicated cache entry for semantic array?
        if ( ! $options['show_instance'] && ! $options['semantic']) {
            return $this->cache['array'] = $array;
        }
        else {
            return $array;
        }
    }

    /**
     */
    public function toString(array $options=[])
    {
        $operator = self::operator;
        if ( ! $this->operands) {

            return "['{$operator}']";
        }

        $indent_unit = isset($options['indent_unit']) ? $options['indent_unit'] : '';
        $line_break  = $indent_unit ? "\n" : '';

        $out = "['{$operator}',"
            . $line_break
            . ($indent_unit ? : ' ')
            . str_replace($line_break, $line_break.$indent_unit, $this->getOperandAt(0)->toString($options))
            . ','
            . $line_break
            . ']'
            ;

        return $out;
    }

    /**
     * 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
     * @param  array          $contextual_options
     * @return OrRule The current instance (of or or subclass) or a new OrRule
     */
    public function setOperandsOrReplaceByOperation(array $new_operands, array $contextual_options)
    {
        if (count($new_operands) > 1) {
            foreach ($new_operands as &$new_operand) {
                if ($new_operand instanceof AbstractRule) {
                    $new_operand = $new_operand->toString();
                }
            }

            throw new \InvalidArgumentException(
                "Negations can handle only one operand instead of: \n"
                .var_export($new_operands, true)
            );
        }

        $new_operand = reset($new_operands);
        // $new_operand->dump();

        if ($new_operand instanceof NotRule) {
            $operands = $new_operand->getOperands();
            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 );
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }
        elseif ($new_operand instanceof InRule && ! $this->getOption('not_in.normalization', $contextual_options)) {
            return new NotInRule( $new_operand->getField(), $new_operand->getPossibilities(), $this->options );
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        // Don't use addOperand here to allow inheritance for optimizations (e.g. NotInRule)
        $out = $this->setOperands($new_operands);

        return $out
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            // ->dump()
            ;
    }

    /**
     *
     */
    public function hasSolution(array $contextual_options=[])
    {
        $operand = $this->getOperandAt(0);

        return $operand instanceof AbstractAtomicRule ? ! $operand->hasSolution($contextual_options) : true;
    }

    /**/
}

NotRule::negateOperand() F
last analyzed 2019-08-15 22:31 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

jclaveau / php-logical-filter

NotRule::negateOperand() F last analyzed 2019-08-15 22:31 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

NotRule::negateOperand() F
last analyzed 2019-08-15 22:31 UTC
