AndRule::simplifySameOperands() - Code Metrics - Inspection of "Yoda style" - jclaveau/php-logical-filter - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (2a417c)

by Jean

created 2018-12-30 16:47 UTC

AndRule::simplifySameOperands() F

↳ Parent: AndRule

Complexity

Conditions	23
Paths	19

Size

Total Lines

120

Duplication

Lines	55
Ratio	45.83 %

Code Coverage

Tests	65
CRAP Score	23.6964

Importance

Changes

Metric	Value
cc	23
nc	19
nop	1
dl	55
loc	120
ccs	65
cts	73
cp	0.8904
crap	23.6964
rs	3.3333
c	0
b	0
f	0

How to fix Long Method Complexity

<?php
namespace JClaveau\LogicalFilter\Rule;
use       JClaveau\VisibilityViolator\VisibilityViolator;

/**
 * Logical conjunction:
 * @see https://en.wikipedia.org/wiki/Logical_conjunction
 */
class AndRule extends AbstractOperationRule
{
    /** @var string operator */
    const operator = 'and';

    /**
     * Replace all the OrRules of the RuleTree by one OrRule at its root.
     *
     * @todo rename as RootifyDisjunjctions?
     * @todo return $this (implements a Rule monad?)
     *
     * @return OrRule copied operands with one OR at its root
     */
    public function rootifyDisjunctions(array $simplification_options)
    {
        if ( ! $this->isNormalizationAllowed($simplification_options)) {
            return $this;
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());
}
        }

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

        $upLiftedOperands = [];
        foreach ($this->getOperands() as $operand) {
            $operand = $operand->copy();
            if ($operand instanceof AbstractOperationRule) {
                $operand = $operand->rootifyDisjunctions($simplification_options);
            }

            $upLiftedOperands[] = $operand;
        }

        // If the AndRule doesn't contain any OrRule , there is nothing to uplift
        if ( ! array_filter($upLiftedOperands, function($operand) {
            return $operand instanceof OrRule;
        })) {
            return new AndRule($upLiftedOperands);
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());
}
        }

        $firstAndOperand = new AndRule();

        // This OrRule should contain only AndRules during its generation
        $upLiftedOr = new OrRule([
            $firstAndOperand,
        ]);

        // var_dump($upLiftedOperands);
        // $this->dump(true);

        foreach ($upLiftedOperands as $i => $operand) {
            if ($operand instanceof NotRule) {
                if (    ($operand instanceof NotEqualRule || $operand instanceof NotInRule)
                    && ! $operand->isNormalizationAllowed($simplification_options)
                ) {
                    foreach ($upLiftedOr->getOperands() as $upLifdtedOperand) {
                        $upLifdtedOperand->addOperand( $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.
    }
}
                    }
                }
                else {
                    throw new \LogicException(
                        "Rootifying disjunctions MUST be done after negations removal instead of '".$operand."' \n"
                        .$operand
                    );
                }
            }
            elseif ($operand instanceof OrRule && $operand->isNormalizationAllowed($simplification_options)) {

                // If an operand is an Or, me transform the current
                // (A' || A") && (B')       <=> (A' && B') || (A" && B');
                // (A' || A") && (B' || B") <=> (A' && B') || (A' && B") || (A" && B') || (A" && B");
                // (A' || A") && (B' || B") && (C' || 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");
                $newUpLiftedOr = new OrRule;
                foreach ($operand->getOperands() as $subOperand) {
                    foreach ($upLiftedOr->getOperands() as $upLiftedOrSubOperand) {
                        $newUpLiftedOrSubOperand = $upLiftedOrSubOperand->copy();
                        $newUpLiftedOrSubOperand->addOperand( $subOperand->copy() );
                        if ($newUpLiftedOrSubOperand->simplify($simplification_options)->hasSolution($simplification_options)) {
                            $newUpLiftedOr->addOperand( $newUpLiftedOrSubOperand );
                        }
                    }
                }

                $upLiftedOr = $newUpLiftedOr;
            }
            else {
                // append the operand to all the operands of the $upLiftedOr
                foreach ($upLiftedOr->getOperands() as $upLifdtedOperand) {
                    if ( ! $upLifdtedOperand instanceof AndRule) {
                        throw new \LogicException(
                             "Operands of the uplifted OrRule MUST be AndRules during"
                            ."the combination."
                        );
                    }

                    $upLifdtedOperand->addOperand( $operand->copy() );
                }
            }
        }

        return $upLiftedOr;
    }

    /**
     * @param array $options   + show_instance=false Display the operator of the rule or its instance id
     *
     * @return array
     *
     * @todo same as OrRule
     */
    public function toArray(array $options=[])

    {
        $default_options = [
            'show_instance' => false,
            'sort_operands' => 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'] && ! empty($this->cache['array'])) {
            return $this->cache['array'];
        }

        $operands_as_array = [
            $options['show_instance'] ? $this->getInstanceId() : self::operator,
        ];

        $operands = $this->operands;
        if ($options['semantic']) {
            // Semantic array: ['operator', 'semantic_id_of_operand1', 'semantic_id_of_operand2', ...]
            // with sorted semantic ids
            $operands_semantic_ids = array_keys($operands);
            sort($operands_semantic_ids);
            return array_merge(
                [self::operator],
                $operands_semantic_ids
            );
        }
        else {
            foreach ($operands as $operand) {
                $operands_as_array[] = $operand->toArray($options);
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.
    }
}
            }

            if ( ! $options['show_instance']) {
                return $this->cache['array'] = $operands_as_array;
            }
            else {
                return $operands_as_array;
            }
        }
    }

    /**
     */
    public function toString(array $options=[])

    {
        $operator = self::operator;
        if ( ! $this->operands) {

            return $this->cache['string'] = "['{$operator}']";
        }

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

        $out = "['{$operator}',$line_break";

        foreach ($this->operands as $operand) {
            $out .= implode("\n", array_map(function($line) use (&$indent_unit) {
                return $indent_unit.$line;
            }, explode("\n", $operand->toString($options)) )) . ",$line_break";

        }

        $out .= ']';

        return $this->cache['string'] = $out;
    }

    /**
     * Remove AndRules operands of AndRules
     */
    public function removeSameOperationOperands()

    {
        foreach ($this->operands as $i => $operand) {
            if ( ! is_a($operand, AndRule::class)) {
                continue;
            }

            if ( ! $operands = $operand->getOperands()) {
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.
    }
}
                continue;
            }

            // Id AND is an operand on AND they can be merge (and the same with OR)
            foreach ($operands as $sub_operand) {
                $this->addOperand( $sub_operand->copy() );
            }
            unset($this->operands[$i]);

            // possibility of mono-operand or dupicates
            $has_been_changed = true;
        }

        return ! empty($has_been_changed);
    }

    /**
     * Removes rule branches that cannot produce result like:
     * A = 1 || (B < 2 && B > 3) <=> A = 1
     *
     * @return AndRule $this
     */
    public function removeInvalidBranches(array $simplification_options)
    {
        if ( ! $this->isNormalizationAllowed($simplification_options)) {
            return $this;
        }

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

        foreach ($this->operands as $i => $operand) {
            // if ($operand instanceof AndRule || $operand instanceof OrRule ) {
            if ( in_array( get_class($operand), [AndRule::class, OrRule::class]) ) {
                $this->operands[$i] = $operand->removeInvalidBranches($simplification_options);
                if ( ! $this->operands[$i]->hasSolution()) {
                    $this->operands = [];
                    return $this;
                }
            }
        }

        $operandsByFields = $this->groupOperandsByFieldAndOperator();

        // $this->dump(true);

        foreach ($operandsByFields as $field => $operandsByOperator) {
            if ( ! empty($operandsByOperator[ EqualRule::operator ])) {
                foreach ($operandsByOperator[ EqualRule::operator ] as $equalRule) {
                    // Multiple equal rules without the same value is invalid
                    if (isset($previousEqualRule) && $previousEqualRule->getValue() != $equalRule->getValue()) {
                        $this->operands = [];
                        return $this;
                    }
                    $previousEqualRule = $equalRule;
                }
                unset($previousEqualRule);

                $equalRule = reset($operandsByOperator[ EqualRule::operator ]);

                if (   ! empty($operandsByOperator[ BelowRule::operator ])

                    && null === $equalRule->getValue()
                ) {
                    $this->operands = [];
                    return $this;
                }

                if (   ! empty($operandsByOperator[ BelowRule::operator ])

                    && $equalRule->getValue() >= reset($operandsByOperator[ BelowRule::operator ])->getMaximum()
                ) {
                    $this->operands = [];
                    return $this;
                }

                if (   ! empty($operandsByOperator[ AboveRule::operator ])

                    && null === $equalRule->getValue()
                ) {
                    $this->operands = [];
                    return $this;
                }

                if (   ! empty($operandsByOperator[ AboveRule::operator ])

                    && $equalRule->getValue() <= reset($operandsByOperator[ AboveRule::operator ])->getMinimum()
                ) {
                    $this->operands = [];
                    return $this;
                }

                if (   ! empty($operandsByOperator[ NotEqualRule::operator ])

                    && $equalRule->getValue() == reset($operandsByOperator[ NotEqualRule::operator ])->getValue()
                ) {
                    $this->operands = [];
                    return $this;
                }

                if (   ! empty($operandsByOperator[ NotEqualRule::operator ])
                    && null === $equalRule->getValue()
                    && null === reset($operandsByOperator[ NotEqualRule::operator ])->getValue()
                ) {
                    $this->operands = [];
                    return $this;
                }
            }
            elseif (   ! empty($operandsByOperator[ BelowRule::operator ])
                    && ! empty($operandsByOperator[ AboveRule::operator ])) {
                $aboveRule = reset($operandsByOperator[ AboveRule::operator ]);
                $belowRule = reset($operandsByOperator[ BelowRule::operator ]);

                if ($belowRule->getMaximum() <= $aboveRule->getMinimum()) {
                    $this->operands = [];
                    return $this;
                }
            }
        }

        return $this;
    }

    /**
     * Checks if a simplified AndRule has incompatible operands like:
     * + a = 3 && a > 4
     * + a = 3 && a < 2
     * + a > 3 && a < 2
     *
     * @return bool If the AndRule can have a solution or not
     */
    public function hasSolution(array $contextual_options=[])

    {
        if ( ! $this->simplicationStepReached(self::simplified)) {

            throw new \LogicException(
                "hasSolution has no sens if the rule is not simplified instead of being at: "
                .var_export($this->current_simplification_step, true)
            );
        }

        // atomic rules
        foreach ($this->getOperands() as $operand) {
            if (method_exists($operand, 'hasSolution') && ! $operand->hasSolution()) {
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.
    }
}
                return false;
            }
        }

        return ! empty($this->getOperands());
    }


    /**
     * + if A > 2 && A > 1 <=> A > 2
     * + if A < 2 && A < 1 <=> A < 1
     */
    protected static function simplifySameOperands(array $operandsByFields)
    {
        // unifying same operands
        foreach ($operandsByFields as $field => $operandsByOperator) {
            foreach ($operandsByOperator as $operator => $operands) {
                unset($previous_operand);

                try {
                    if (AboveRule::operator == $operator) {
                        usort($operands, function( AboveRule $a, AboveRule $b ) {
                            if (null === $a->getMinimum()) {

                                return 1;
                            }

                            if (null === $b->getMinimum()) {

                                return -1;
                            }

                            if ($a->getMinimum() > $b->getMinimum()) {

                                return -1;
                            }

                            return 1;
                        });
                        $operands = [reset($operands)];
                    }
                    elseif (BelowRule::operator == $operator) {

                        usort($operands, function( BelowRule $a, BelowRule $b ) {
                            if (null === $a->getMaximum()) {

                                return 1;
                            }

                            if (null === $b->getMaximum()) {

                                return -1;
                            }

                            if ($a->getMaximum() < $b->getMaximum()) {

                                return -1;
                            }

                            return 1;
                        });
                        $operands = [reset($operands)];
                    }
                    elseif (EqualRule::operator == $operator) {
                        // TODO add an option for the support strict comparison
                        foreach ($operands as $i => $operand) {
                            if ( ! isset($previous_operand)) {
                                $previous_operand = $operand;
                                continue;
                            }

                            if ($previous_operand == $operand) {
                                unset($operands[$i]);
                                continue;
                            }
                            else {
                                // Same field expected to be two differents
                                // values at the same time has no sens so
                                // we remove all the operands of the current
                                // AndRule (TODO FalseRule)
                                return [];
                            }
                        }
                    }
                    elseif (InRule::operator == $operator) {

                        $first_in = reset($operands);

                        foreach ($operands as $i => $next_in) {
                            if ($first_in === $next_in) {
                                continue;
                            }

                            $first_in->setPossibilities( array_intersect(
                                $first_in->getPossibilities(),
                                $next_in->getPossibilities()
                            ) );

                            unset($operands[$i]);
                        }

                        // [field in []] <=> false
                        if ( ! $first_in->getPossibilities()) {
                            return [];
                        }
                    }
                    elseif (NotInRule::operator == $operator) {

                        $first_not_in = reset($operands);

                        foreach ($operands as $i => $next_not_in) {
                            if ($first_not_in === $next_not_in) {
                                continue;
                            }

                            $first_not_in->setPossibilities( array_merge(
                                $first_not_in->getPossibilities(),
                                $next_not_in->getPossibilities()
                            ) );

                            unset($operands[$i]);
                        }
                    }
                }
                catch (\Exception $e) {
                    VisibilityViolator::setHiddenProperty($e, 'message', $e->getMessage() . "\n" . var_export([
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                            'operands' => $operands,
                            // 'this'     => $this,
                        ], true)
                    );

                    // \Debug::dumpJson($this->toArray(), true);
                    throw $e;
                }

                $operandsByFields[ $field ][ $operator ] = $operands;
            }
        }

        return $operandsByFields;
    }

    /**
     */
    protected static function simplifyDifferentOperands(array $operandsByFields)
    {
        foreach ($operandsByFields as $field => &$operandsByOperator) {
            foreach ([
                    EqualRule::operator,
                    AboveRule::operator,
                    AboveRule::operator,
                    InRule::operator,
                    NotInRule::operator,
                    BelowOrEqualRule::operator,
                    AboveOrEqualRule::operator,
                ]
                as $unifyable_operator
            ) {
                if ( ! empty($operandsByOperator[ $unifyable_operator ])) {
                    if (1 != count($operandsByOperator[ $unifyable_operator ])) {
                        throw new \LogicException(
                            __METHOD__ . " MUST be called after unifyAtomicOperands() "
                            ."to have only one '$unifyable_operator' predicate istead of:\n"
                            ."[\n".implode( ",\n", array_map(function ($rule) {
                                return $rule->toString();
                            }, $operandsByOperator[ $unifyable_operator ])
                            )."\n]"
                        );
                    }
                }
            }

            $operandsByOperator = self::simplifyDifferentOperandsForField($field, $operandsByOperator);
            // If tyhere is no more operands for a given field it means there
            // is no possible solutions for it so all the current and_case
            // is invalidated.
            if ( ! $operandsByOperator) {
                return [];
            }
        }

        return $operandsByFields;
    }

    /**
     * + if A = 2 && A > 1 <=> A = 2
     * + if A = 2 && A < 4 <=> A = 2
     */
    protected static function simplifyDifferentOperandsForField($field, array $operandsByOperator)
    {
        // EqualRule comparisons
        if ( ! empty($operandsByOperator[ EqualRule::operator ])) {
            $equalRule = reset( $operandsByOperator[ EqualRule::operator ] );

            if ( ! empty($operandsByOperator[ NotEqualRule::operator ])) {
                foreach ($operandsByOperator[ NotEqualRule::operator ] as $i => $not_equal_rule) {
                    if (null !== $equalRule->getValue()) {
                        if (null === $not_equal_rule->getValue()) { // means if exists <=> equals something
                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                        }
                        elseif ($not_equal_rule->getValue() != $equalRule->getValue()) {
                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                        }
                    }
                    elseif (null === $equalRule->getValue() ) {
                        if (null !== $not_equal_rule->getValue()) {
                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                        }
                        // else we let the "equal null" and the "not equal null" for the romeInvalidBranches step
                    }
                }
            }

            if ( ! empty($operandsByOperator[ AboveRule::operator ])) {

                $aboveRule = reset($operandsByOperator[ AboveRule::operator ]);
                if (null !== $equalRule->getValue() && $aboveRule->getMinimum() < $equalRule->getValue()) {
                    unset($operandsByOperator[ AboveRule::operator ]);
                }
            }

            if ( ! empty($operandsByOperator[ BelowRule::operator ])) {

                $belowRule = reset($operandsByOperator[ BelowRule::operator ]);
                if (null !== $equalRule->getValue() && $belowRule->getMaximum() > $equalRule->getValue()) {
                    unset($operandsByOperator[ BelowRule::operator ]);
                }
            }

            if ( ! empty($operandsByOperator[ InRule::operator ])) {
                $possibilities = reset($operandsByOperator[ InRule::operator ])->getPossibilities();

                if (in_array($equalRule->getValue(), $possibilities)) {
                    unset($operandsByOperator[ InRule::operator ]);
                }
                else {
                    // We flush possibilities of the InRule
                    // TODO Replace it by a FalseRule
                    $operandsByOperator[ InRule::operator ][0]->setPossibilities([]);
                    // and also remove the equal rule to shorten the reste of the simplification process
                    unset($operandsByOperator[ EqualRule::operator ]);
                }
            }

            if ( ! empty($operandsByOperator[ NotInRule::operator ])) {
                $notInRule = reset($operandsByOperator[ NotInRule::operator ]);
                if (in_array($equalRule->getValue(), $notInRule->getPossibilities())) {
                    // ['field', '=', 4] && ['field', '!in', [4]...] <=> false
                    return [];
                }
                else {
                    unset($operandsByOperator[ NotInRule::operator ]);
                }
                // $notInRule->dump(true);
            }

            if ( ! empty($operandsByOperator[ BelowOrEqualRule::operator ])) {

                $belowOrEqualRule = reset($operandsByOperator[ BelowOrEqualRule::operator ]);
                if ($equalRule->getValue() <= $belowOrEqualRule->getMaximum()) {
                    unset($operandsByOperator[ BelowOrEqualRule::operator ]);
                }
                else {
                    // ['field', '=', 4] && ['field', '<=', [3]...] <=> false
                    return [];
                }
            }

            if ( ! empty($operandsByOperator[ AboveOrEqualRule::operator ])) {

                $aboveOrEqualRule = reset($operandsByOperator[ AboveOrEqualRule::operator ]);
                if ($equalRule->getValue() >= $aboveOrEqualRule->getMinimum()) {
                    unset($operandsByOperator[ AboveOrEqualRule::operator ]);
                }
                else {
                    // ['field', '=', 4] && ['field', '<=', [3]...] <=> false
                    return [];
                }
            }
        }

        // NotEqualRule null comparisons
        if ( ! empty($operandsByOperator[ NotEqualRule::operator ])) {
            if ( ! empty($operandsByOperator[ NotEqualRule::operator ])) {
                foreach ($operandsByOperator[ NotEqualRule::operator ] as $i => $notEqualRule) {
                    if (null === $notEqualRule->getValue()) {
                        if ( ! empty($operandsByOperator[ AboveRule::operator ])) {
                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                        }

                        if ( ! empty($operandsByOperator[ BelowRule::operator ])) {
                            unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                        }

                        if ( ! empty($operandsByOperator[ EqualRule::operator ])) {
                            if (null !== reset($operandsByOperator[ EqualRule::operator ])->getValue()) {
                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                            }
                        }
                    }
                    else {
                        if ( ! empty($operandsByOperator[ AboveRule::operator ])) {

                            if ($operandsByOperator[ AboveRule::operator ][0]->getMinimum() >= $notEqualRule->getValue()) {
                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                            }
                        }

                        if ( ! empty($operandsByOperator[ BelowRule::operator ])) {

                            if ($operandsByOperator[ BelowRule::operator ][0]->getMaximum() <= $notEqualRule->getValue()) {
                                unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                            }
                        }
                    }

                    if ( ! empty($operandsByOperator[ NotInRule::operator ])) {
                        $notInRule = reset($operandsByOperator[ NotInRule::operator ]);
                        if ( ! in_array($notEqualRule->getValue(), $notInRule->getPossibilities())) {
                            // TODO Replace it by a FalseRule
                            $operandsByOperator[ NotInRule::operator ][0]->setPossibilities(
                                array_merge($notInRule->getPossibilities(), [$notEqualRule->getValue()])
                            );
                        }

                        unset($operandsByOperator[ NotEqualRule::operator ][$i]);
                    }

                    if ( ! empty($operandsByOperator[ InRule::operator ])) {
                        $inRule = reset($operandsByOperator[ InRule::operator ]);

                        $operandsByOperator[ InRule::operator ][0]->setPossibilities(
                            array_diff($inRule->getPossibilities(), [$notEqualRule->getValue()])
                        );
                    }
                }
            }
        }

        // Comparison between InRules and NotInRules
        // This is an optimization to avoid NotIn explosion
        if ( ! empty($operandsByOperator[ InRule::operator ])) {
            $inRule = $operandsByOperator[ InRule::operator ][0];

            if ( ! empty($operandsByOperator[ NotInRule::operator ])) {

                $notInRule = reset($operandsByOperator[ NotInRule::operator ]);
                $operandsByOperator[ InRule::operator ][0]->setPossibilities(
                    array_diff( $inRule->getPossibilities(), $notInRule->getPossibilities())
                );
                unset($operandsByOperator[ NotInRule::operator ]);
            }

            if ( ! empty($operandsByOperator[ BelowRule::operator ])) {

                $upper_limit = reset($operandsByOperator[ BelowRule::operator ])->getMaximum();

                $operandsByOperator[ InRule::operator ][0]->setPossibilities(
                    array_filter( $inRule->getPossibilities(), function ($possibility) use ($upper_limit) {
                        return $possibility < $upper_limit;
                    } )
                );

                unset($operandsByOperator[ BelowRule::operator ]);
            }

            if ( ! empty($operandsByOperator[ AboveRule::operator ])) {

                $lower_limit = reset($operandsByOperator[ AboveRule::operator ])->getMinimum();

                $operandsByOperator[ InRule::operator ][0]->setPossibilities(
                    array_filter( $inRule->getPossibilities(), function ($possibility) use ($lower_limit) {
                        return $possibility > $lower_limit;
                    } )
                );

                unset($operandsByOperator[ AboveRule::operator ]);
            }
        }

        // Comparison between NotInRules and > or <
        if ( ! empty($operandsByOperator[ NotInRule::operator ])) {
            $notInRule = $operandsByOperator[ NotInRule::operator ][0];

            if ( ! empty($operandsByOperator[ BelowRule::operator ])) {

                $upper_limit = reset($operandsByOperator[ BelowRule::operator ])->getUpperLimit();

                $operandsByOperator[ NotInRule::operator ][0]->setPossibilities(
                    array_filter( $notInRule->getPossibilities(), function ($possibility) use ($upper_limit) {
                        return $possibility < $upper_limit;
                    } )
                );
            }

            if ( ! empty($operandsByOperator[ AboveRule::operator ])) {

                $lower_limit = reset($operandsByOperator[ AboveRule::operator ])->getMinimum();

                $operandsByOperator[ NotInRule::operator ][0]->setPossibilities(
                    array_filter( $notInRule->getPossibilities(), function ($possibility) use ($lower_limit) {
                        return $possibility > $lower_limit;
                    } )
                );
            }
        }

        // Comparison between <= and > or <
        if ( ! empty($operandsByOperator[ BelowOrEqualRule::operator ])) {
            $belowOrEqualRule = $operandsByOperator[ BelowOrEqualRule::operator ][0];

            if ( ! empty($operandsByOperator[ BelowRule::operator ])) {
                $upper_limit = reset($operandsByOperator[ BelowRule::operator ])->getUpperLimit();

                if ($belowOrEqualRule->getMaximum() >= $upper_limit) {
                    // [field < 3] && [field <= 3]
                    // [field < 3] && [field <= 4]
                    unset($operandsByOperator[ BelowOrEqualRule::operator ][0]);
                }
                else {
                    // [field < 3] && [field <= 2]
                    unset($operandsByOperator[ BelowRule::operator ][0]);
                }
            }

            if ( ! empty($operandsByOperator[ AboveRule::operator ])) {

                $lower_limit = reset($operandsByOperator[ AboveRule::operator ])->getLowerLimit();

                if ($belowOrEqualRule->getMaximum() <= $lower_limit) {
                    // [field > 3] && [field <= 2] <=> false
                    return [];
                }
            }

            if ( ! empty($operandsByOperator[ AboveOrEqualRule::operator ])) {
                $minimum = reset($operandsByOperator[ AboveOrEqualRule::operator ])->getMinimum();

                if ($belowOrEqualRule->getMaximum() < $minimum) {
                    // [field <= 3] && [field >= 4] <=> false
                    return [];
                }
                elseif ($belowOrEqualRule->getMaximum() == $minimum) {
                    // [field <= 3] && [field >= 3] <=> [field = 3]
                    unset($operandsByOperator[ BelowOrEqualRule::operator ]);
                    unset($operandsByOperator[ AboveOrEqualRule::operator ]);
                    $operandsByOperator[ EqualRule::operator ][] = new EqualRule($field, $minimum);

                    if (count($operandsByOperator[ EqualRule::operator ]) > 1) {
                        $operandsByOperator = self::simplifyDifferentOperandsForField($field, $operandsByOperator);
                    }
                }
            }
        }

        return $operandsByOperator;
    }

    /**
     * This method is meant to be used during simplification that would
     * need to change the class of the current instance by a normal one.
     *
     * @return AndRule The current instance (of or or subclass) or a new AndRule
     */
    public function setOperandsOrReplaceByOperation($new_operands)
    {
        try {
            return $this->setOperands( $new_operands );
        }
        catch (\LogicException $e) {
            return new AndRule( $new_operands );
        }
    }

    /**/
}


Branch — master (2a417c)

AndRule::simplifySameOperands() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1		<?php
2		namespace JClaveau\LogicalFilter\Rule;
3		use JClaveau\VisibilityViolator\VisibilityViolator;
4
5		/**
6		* Logical conjunction:
7		* @see https://en.wikipedia.org/wiki/Logical_conjunction
8		*/
9		class AndRule extends AbstractOperationRule
10		{
11		/** @var string operator */
12		const operator = 'and';
13
14		/**
15		* Replace all the OrRules of the RuleTree by one OrRule at its root.
16		*
17		* @todo rename as RootifyDisjunjctions?
18		* @todo return $this (implements a Rule monad?)
19		*
20		* @return OrRule copied operands with one OR at its root
21		*/
22	98	public function rootifyDisjunctions(array $simplification_options)
23		{
24	98	if ( ! $this->isNormalizationAllowed($simplification_options)) {
25		return $this;
		0 ignored issues – show Bug Best Practice introduced 2018-12-30 16:52 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`JClaveau\LogicalFilter\Rule\AndRule`) is incompatible with the return type documented by `JClaveau\LogicalFilter\R...le::rootifyDisjunctions` of type `JClaveau\LogicalFilter\Rule\OrRule`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: 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()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
26		}
27
28	98	$this->moveSimplificationStepForward( self::rootify_disjunctions, $simplification_options );
29
30	98	$upLiftedOperands = [];
31	98	foreach ($this->getOperands() as $operand) {
32	95	$operand = $operand->copy();
33	95	if ($operand instanceof AbstractOperationRule) {
34	56	$operand = $operand->rootifyDisjunctions($simplification_options);
35	56	}
36
37	95	$upLiftedOperands[] = $operand;
38	98	}
39

jclaveau / php-logical-filter

Branch — master (2a417c)

AndRule::simplifySameOperands() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like