JClaveau\LogicalFilter\Rule\AbstractRule::flushStaticCache()

Complexity

Conditions	1
Paths	1

Size

Total Lines

6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
	AbstractRule::toArray()	0	1	?

<?php
namespace JClaveau\LogicalFilter\Rule;

abstract class AbstractRule implements \JsonSerializable
{
    use Trait_RuleWithOptions;
    use Trait_RuleWithCache;

    /** @var  array $ruleAliases */
    protected static $ruleAliases = [
        '!'    => 'not',
        '='    => 'equal',
        '>'    => 'above',
        '<'    => 'below',
        '><'   => 'between',
        '=><'  => 'between_or_equal_lower',
        '><='  => 'between_or_equal_upper',
        '=><=' => 'between_or_equal_both',
        '<='   => 'below_or_equal',
        '>='   => 'above_or_equal',
        '!='   => 'not_equal',
        'in'   => 'in',
        '!in'  => 'not_in',
    ];

    /**
     * @param  string $english_operator
     * @return string
     */
    public static function findSymbolicOperator($english_operator)
    {
        $association = array_flip( self::$ruleAliases );
        if (isset($association[ $english_operator ])) {
            return $association[ $english_operator ];
        }

        return $english_operator;
    }

    /**
     * @param  string $symbolic_operator
     * @return string
     */
    public static function findEnglishOperator($symbolic_operator)
    {
        $association = self::$ruleAliases;
        if (isset($association[ $symbolic_operator ])) {
            return $association[ $symbolic_operator ];
        }

        return $symbolic_operator;
    }

    /**
     *
     * @param  string $field
     * @param  string $type
     * @param  mixed  $values
     * @param  array  $options
     *
     * @return AbstractRule
     */
    public static function generateSimpleRule($field, $type, $values, array $options=[])
    {
        $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 );
    }

    /**
     * @param  string $rule_operator
     *
     * @return string Class corresponding to the given operator
     */
    public static function getRuleClass($rule_operator)
    {
        $english_rule_operator = self::findEnglishOperator($rule_operator);

        $rule_class = __NAMESPACE__
            . '\\'
            . str_replace('_', '', ucwords($english_rule_operator, '_'))
            . 'Rule';

        if ( ! class_exists( $rule_class)) {
            throw new \InvalidArgumentException(
                "The class '$rule_class' corresponding to the  operator "
                ."'$rule_operator' / '$english_rule_operator' cannot be found."
            );
        }

        return $rule_class;
    }

    /**
     * Clones the rule with a chained syntax.
     *
     * @return AbstractRule A copy of the current instance.
     */
    public function copy()
    {
        return clone $this;
    }

    /**
     * Dumps the rule with a chained syntax.
     *
     * @param bool  $exit       Default false
     * @param array $options    + callstack_depth=2 The level of the caller to dump
     *                          + mode='string' in 'export' | 'dump' | 'string' | 'xdebug'
     *
     * @return $this

Should the return type not be AbstractRule|null?

     */
    final public function dump($exit=false, array $options=[])
    {
        $default_options = [
            'callstack_depth' => 2,
            'mode'            => 'string',
            // 'show_instance'   => false,
        ];
        foreach ($default_options as $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 ];

        echo "\n" . $caller['file'] . ':' . $caller['line'] . "\n";
        if ('string' == $mode) {
            if ( ! isset($options['indent_unit'])) {
                $options['indent_unit'] = "    ";
            }

            echo($this->toString($options));
        }
        elseif ('dump' == $mode) {
            if ($xdebug_enabled = ini_get('xdebug.overload_var_dump')) {
                ini_set('xdebug.overload_var_dump', 0);
            }

            var_dump($this->toArray($options));

            if ($xdebug_enabled) {
                ini_set('xdebug.overload_var_dump', 1);
            }
        }
        elseif ('xdebug' == $mode) {
            if ( ! function_exists('xdebug_is_enabled')) {
                throw new \RuntimeException("Xdebug is not installed");
            }
            if ( ! xdebug_is_enabled()) {
                throw new \RuntimeException("Xdebug is disabled");
            }

            if ($xdebug_enabled = ini_get('xdebug.overload_var_dump')) {
                ini_set('xdebug.overload_var_dump', 1);
            }

            var_dump($this->toArray($options));

            if ($xdebug_enabled) {
                ini_set('xdebug.overload_var_dump', 0);
            }
        }
        elseif ('export' == $mode) {
            var_export($this->toArray($options));
        }
        else {
            throw new \InvalidArgumentException(
                 "'mode' option must belong to ['string', 'export', 'dump'] "
                ."instead of " . var_export($mode, true)
            );
        }
        echo "\n\n";

        if ($exit) {
            exit;
        }

        return $this;
    }

    /**
     * For implementing JsonSerializable interface.
     *
     * @see https://secure.php.net/manual/en/jsonserializable.jsonserialize.php
     */
    public function jsonSerialize()
    {
        return $this->toArray();
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return $this->toString();
    }

    /**
     * @return string
     */
    abstract public function toString(array $options=[]);

    /**
     * @return array
     */
    abstract public function toArray(array $options=[]);

    protected $instance_id;

    /**
     * Returns an id describing the instance internally for debug purpose.
     *
     * @see https://secure.php.net/manual/en/function.spl-object-id.php
     *
     * @return string
     */
    public function getInstanceId()
    {
        if ($this->instance_id) {
            return $this->instance_id;
        }

        return $this->instance_id = get_class($this).':'.spl_object_id($this);
    }

    /**
     * Returns an id corresponding to the meaning of the rule.
     *
     * @return string
     */
    final public function getSemanticId()
    {
        if (isset($this->cache['semantic_id'])) {
            return $this->cache['semantic_id'];
        }

        return hash('md4', serialize( $this->toArray(['semantic' => true]) ))  // faster but longer
              .'-'
              .hash('md4', serialize( $this->options ))
              ;
    }

    /**
     * @deprecated addMinimalCase
     */
    protected function forceLogicalCore()
    {
        return $this->addMinimalCase();
    }

    /**
     * Forces the two firsts levels of the tree to be an OrRule having
     * only AndRules as operands:
     * ['field', '=', '1'] <=> ['or', ['and', ['field', '=', '1']]]
     * As a simplified ruleTree will alwways be reduced to this structure
     * with no suboperands others than atomic ones or a simpler one like:
     * ['or', ['field', '=', '1'], ['field2', '>', '3']]
     *
     * This helpes to ease the result of simplify()
     *
     * @return OrRule
     */
    public function addMinimalCase()
    {
        // Simplification step is required to call hasSolution() on the
        // returned OrRule value
        if ($this instanceof AndRule || $this instanceof OrRule) {
            $simplification_step_to_keep = $this->getSimplificationStep();

It seems like you code against a specific sub-type and not the parent class JClaveau\LogicalFilter\Rule\AbstractRule as the method getSimplificationStep() does only exist in the following sub-classes of JClaveau\LogicalFilter\Rule\AbstractRule: JClaveau\LogicalFilter\Rule\AboveOrEqualRule, JClaveau\LogicalFilter\Rule\AbstractOperationRule, JClaveau\LogicalFilter\Rule\AndRule, JClaveau\LogicalFilter\Rule\BelowOrEqualRule, JClaveau\LogicalFilter\Rule\BetweenOrEqualBothRule, JClaveau\LogicalFilter\Rule\BetweenOrEqualLowerRule, JClaveau\LogicalFilter\Rule\BetweenOrEqualUpperRule, JClaveau\LogicalFilter\Rule\BetweenRule, JClaveau\LogicalFilter\Rule\InRule, JClaveau\LogicalFilter\Rule\NotEqualRule, JClaveau\LogicalFilter\Rule\NotInRule, JClaveau\LogicalFilter\Rule\NotRule, JClaveau\LogicalFilter\Rule\OrRule. Maybe you want to instanceof check for one of these explicitly?

        }
        elseif ($this->hasSolution()) {

It seems like you code against a specific sub-type and not the parent class JClaveau\LogicalFilter\Rule\AbstractRule as the method hasSolution() does only exist in the following sub-classes of JClaveau\LogicalFilter\Rule\AbstractRule: JClaveau\LogicalFilter\Rule\AboveOrEqualRule, JClaveau\LogicalFilter\Rule\AboveRule, JClaveau\LogicalFilter\Rule\AndRule, JClaveau\LogicalFilter\Rule\BelowOrEqualRule, JClaveau\LogicalFilter\Rule\BelowRule, JClaveau\LogicalFilter\Rule\BetweenOrEqualBothRule, JClaveau\LogicalFilter\Rule\BetweenOrEqualLowerRule, JClaveau\LogicalFilter\Rule\BetweenOrEqualUpperRule, JClaveau\LogicalFilter\Rule\BetweenRule, JClaveau\LogicalFilter\Rule\EqualRule, JClaveau\LogicalFilter\Rule\InRule, JClaveau\LogicalFilter\Rule\NotEqualRule, JClaveau\LogicalFilter\Rule\NotInRule, JClaveau\LogicalFilter\Rule\NotRule, JClaveau\LogicalFilter\Rule\OrRule, JClaveau\LogicalFilter\Rule\RegexpRule. Maybe you want to instanceof check for one of these explicitly?

            $simplification_step_to_keep = AbstractOperationRule::simplified;
        }
        else {
            $simplification_step_to_keep = null;
        }

        if (   $this instanceof AbstractAtomicRule
            || $this instanceof NotRule
            || $this instanceof InRule
            || ! $this->isNormalizationAllowed([])

It seems like you code against a specific sub-type and not the parent class JClaveau\LogicalFilter\Rule\AbstractRule as the method isNormalizationAllowed() does only exist in the following sub-classes of JClaveau\LogicalFilter\Rule\AbstractRule: JClaveau\LogicalFilter\Rule\AboveOrEqualRule, JClaveau\LogicalFilter\Rule\AbstractOperationRule, JClaveau\LogicalFilter\Rule\AndRule, JClaveau\LogicalFilter\Rule\BelowOrEqualRule, JClaveau\LogicalFilter\Rule\BetweenOrEqualBothRule, JClaveau\LogicalFilter\Rule\BetweenOrEqualLowerRule, JClaveau\LogicalFilter\Rule\BetweenOrEqualUpperRule, JClaveau\LogicalFilter\Rule\BetweenRule, JClaveau\LogicalFilter\Rule\InRule, JClaveau\LogicalFilter\Rule\NotEqualRule, JClaveau\LogicalFilter\Rule\NotInRule, JClaveau\LogicalFilter\Rule\NotRule, JClaveau\LogicalFilter\Rule\OrRule. Maybe you want to instanceof check for one of these explicitly?

        ) {
            $ruleTree = new OrRule([
                new AndRule([
                    $this,
                ]),
            ]);
        }
        elseif ($this instanceof AndRule) {
            $ruleTree = new OrRule([
                $this,
            ]);
        }
        elseif ($this instanceof OrRule) {
            foreach ($this->operands as $i => $operand) {
                if (! $operand instanceof AndRule) {
                    $this->operands[$i] = new AndRule([$operand]);

The property operands does not exist. Did you maybe forget to declare it?

                }
            }
            $ruleTree = $this;
        }
        else {
            throw new \LogicException(
                "Unhandled type of simplified rules provided for conversion: "
                .$this
            );
        }

        if ($simplification_step_to_keep) {
            foreach ($operands = $ruleTree->getOperands() as $andOperand) {
                if (! $andOperand instanceof AndRule) {
                    throw new \LogicException(
                        "A rule is intended to be an and case: \n"
                        .$andOperand
                        ."\nof:\n"
                        .$ruleTree
                    );
                }

                $andOperand->moveSimplificationStepForward($simplification_step_to_keep, [], true);
            }
            $ruleTree->setOperands($operands);
            $ruleTree->moveSimplificationStepForward($simplification_step_to_keep, [], true);
        }


        return $ruleTree;
    }

    /**/
}