JClaveau\LogicalFilter\Rule\NotEqualRule

Complexity

Total Complexity

15

Size/Duplication

Total Lines	111
Duplicated Lines	25.23 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

97.56%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	isNormalizationAllowed()	0	9	2
A	getValue()	0	4	1
A	getValues()	0	4	1
B	toArray()	28	28	7
A	toString()	0	13	2
A	hasSolution()	0	4	1

<?php
namespace JClaveau\LogicalFilter\Rule;

/**
 * a != x
 */
class NotEqualRule extends NotRule
{
    use Trait_RuleWithField;

    /** @var string operator */
    const operator = '!=';

    /** @var mixed value */
    protected $value;

    /**
     * @param string $field The field to apply the rule on.
     * @param mixed  $value The value the field can equal to.
     */
    public function __construct( $field, $value, array $options=[] )
    {
        $this->field = $field;
        $this->value = $value;

        // TODO use the operand instead of properties or don't create EqualRule
        parent::__construct(new EqualRule($field, $value), $options);
    }

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

$operand is not used, you could remove the assignment.

        $out = parent::isNormalizationAllowed()
            && $this->getOption('not_equal.normalization', $contextual_options)
            ;
        return $out;
    }

    /**
     */
    public function getValue()
    {
        return $this->value;
    }

    /**
     */
    public function getValues()
    {
        return $this->getValue();
    }

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

This method seems to be duplicated in your project.

    {
        $default_options = [
            'show_instance' => 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 = [
            $this->getField(),
            $options['show_instance'] ? $this->getInstanceId() : self::operator,
            $this->getValue(),
        ];

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

    /**
     */
    public function toString(array $options=[])
    {
        if ( ! empty($this->cache['string'])) {
            return $this->cache['string'];
        }

        $class    = get_class($this);
        $operator = $class::operator;

        $stringified_value = var_export($this->getValues(), true);

        return $this->cache['string'] = "['{$this->getField()}', '$operator', $stringified_value]";
    }

    /**
     * By default, every atomic rule can have a solution by itself
     *
     * @return bool
     */
    public function hasSolution(array $simplification_options=[])
    {
        return true;
    }

    /**/
}