JClaveau\LogicalFilter\Rule\Trait_RuleWithField

Complexity

Total Complexity

10

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

81.82%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getField()	0	4	1
A	setField()	0	16	3
A	renameField()	0	5	1
A	renameFields_andReturnIsChanged()	0	29	5

<?php
/**
 * Trait_RuleWithField
 *
 * @package php-logical-filter
 * @author  Jean Claveau
 */
namespace JClaveau\LogicalFilter\Rule;

trait Trait_RuleWithField
{
    /** @var string $field The field to apply the rule on */
    protected $field;

    /**
     * @return string $field
     */
    final public function getField()
    {
        return $this->field;
    }

    /**
     * @return string $field

Should the return type not be Trait_RuleWithField?

     */
    final public function setField( $field )
    {
        if ( ! is_scalar($field)) {
            throw new \InvalidArgumentEXception(
                "\$field property of a logical rule must be a scalar contrary to: "
                .var_export($field, true)
            );
        }

        if ($this->field != $field) {
            $this->field = $field;
            $this->flushCache();

It seems like flushCache() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        return $this;
    }

    /**
     * Changes the field property of the rule.
     *
     * @param  array|callable Associative array of renamings or callable
     *                        that would rename the fields.
     *
     * @return AbstractAtomicRule $this

Should the return type not be Trait_RuleWithField?

     */
    final public function renameField($renamings)
    {
        $this->renameFields_andReturnIsChanged($renamings);
        return $this;
    }

    /**
     * Changes the field property of the rule.
     *
     * @param  array|callable Associative array of renamings or callable
     *                        that would rename the fields.
     *
     * @return bool Whether or not the field changed
     */
    final public function renameFields_andReturnIsChanged($renamings)
    {
        $old_field = $this->field;

        if (is_callable($renamings)) {
            $this->setField( call_user_func($renamings, $this->field) );
        }
        elseif (is_array($renamings)) {
            if (isset($renamings[$this->field])) {
                $this->setField( $renamings[$this->field] );
            }
        }
        else {
            throw new \InvalidArgumentException(
                "\$renamings MUST be a callable or an associative array "
                ."instead of: " . var_export($renamings, true)
            );
        }

        if ($old_field != $this->field) {
            $this->flushCache();

It seems like flushCache() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            return true;
        }

        // TODO remove this forced cache flushing ONLY when carefully
        // unit tested
        $this->flushCache();

It seems like flushCache() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return false;
    }

    /**/
}