Mbright\Validation\Spec\AbstractSpec

Complexity

Total Complexity

24

Size/Duplication

Total Lines	292
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	1

Test Coverage

Coverage

98.11%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	__invoke()	0	4	1
A	setMessage()	0	6	1
A	getField()	0	4	1
A	getMessage()	0	8	2
A	getArgs()	0	4	1
A	getRuleClass()	0	4	1
A	setRule()	0	11	2
A	setBlankValues()	0	6	1
A	asHaltingRule()	0	6	1
A	asHardRule()	0	6	1
A	asSoftRule()	0	6	1
A	getFailureMode()	0	4	1
B	subjectFieldIsBlank()	0	21	6
A	getDefaultMessage()	0	4	1
A	argsTostring()	0	8	2

<?php

namespace Mbright\Validation\Spec;

use Mbright\Validation\Exception\RuleClassNotDefinedException;
use Mbright\Validation\Exception\ValidationException;

abstract class AbstractSpec
{
    /**
     * Failure Mode for a halting failure.
     *
     * @var string
     */
    const HALTING_FAILURE = 'HALTING_FAILURE';

    /**
     * Failure Mode for a hard failure.
     *
     * @var string
     */
    const HARD_FAILURE = 'HARD_FAILURE';

    /**
     * Failure Mode for a soft failure.
     *
     * @var string
     */
    const SOFT_FAILURE = 'SOFT_FAILURE';

    /**
     * Field name for the spec to operate on.
     *
     * @var string
     */
    protected $field;

    /**
     * Rule to invoke.
     *
     * @var callable
     */
    protected $rule;

    /**
     * Arguments supplied to the rule
     *
     * @var array
     */
    protected $args = [];

    /**
     * Failure message to be used instead of the default message.
     *
     * @var string
     */
    protected $message;

    /**
     * Name of the rule to execute.
     *
     * @var string
     */
    protected $ruleClass;

    /**
     * Flag that determines the allowance of blank values.
     *
     * @var bool
     */
    protected $allowBlanks = false;

    /**
     * An array of values to be considered blank.
     *
     * @var array
     */
    protected $blankWhiteList = [];

    /**
     * AbstractSpec constructor.
     *
     * @param string $field
     */
    public function __construct(string $field)
    {
        $this->field = $field;
    }

    /**
     * Invokes the rule that this spec is configured for.
     *
     * @param object $subject
     *
     * @return bool
     */
    public function __invoke($subject): bool
    {
        return ($this->rule)($subject, $this->field, ...array_values($this->args));
    }

    /**
     * Set a custom message.
     *
     * @param string $message
     *
     * @return self
     */
    public function setMessage(string $message): self
    {
        $this->message = $message;

        return $this;
    }

    /**
     * Returns the field this spec applies to.
     *
     * @return string
     */
    public function getField(): string
    {
        return $this->field;
    }

    /**
     * Returns the failure message for this rule specification.
     *
     * @return string
     */
    public function getMessage(): string
    {
        if (!$this->message) {
            $this->message = $this->getDefaultMessage();
        }

        return $this->message;
    }

    /**
     * Returns the args this spec is configured to use.
     *
     * @return array
     */
    public function getArgs(): array
    {
        return $this->args;
    }

    /**
     * Returns the name of the rule that was ran.
     *
     * @return string
     */
    public function getRuleClass(): string
    {
        return $this->ruleClass;
    }

    /**
     * Sets the rule and ruleClass for the spec.
     *
     * @param string $ruleClass
     *
     * @throws RuleClassNotDefinedException
     *
     * @return AbstractSpec
     */
    public function setRule(string $ruleClass): self
    {
        if (!class_exists($ruleClass)) {
            throw new RuleClassNotDefinedException("Could not find mapping for [$ruleClass]");
        }

        $this->rule = new $ruleClass();
        $this->ruleClass = $ruleClass;

        return $this;
    }

    /**
     * Sets the white list of values that should be considered blank.
     *
     * @param array $blankWhiteList
     *
     * @return ValidateSpec
     */
    public function setBlankValues(array $blankWhiteList): self
    {
        $this->blankWhiteList = $blankWhiteList;

        return $this;
    }

    /**
     * Sets the rule to halt the entire validation process on the subject.
     *
     * @return AbstractSpec
     */
    public function asHaltingRule(): self
    {
        $this->failureMode = self::HALTING_FAILURE;

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

        return $this;
    }

    /**
     * Sets the rule to stop further rules from applying to the same field.
     *
     * @return AbstractSpec
     */
    public function asHardRule(): self
    {
        $this->failureMode = self::HARD_FAILURE;

        return $this;
    }

    /**
     * Sets the rule to allow other rules to operate on the same field.
     *
     * @return AbstractSpec
     */
    public function asSoftRule(): self
    {
        $this->failureMode = self::SOFT_FAILURE;

        return $this;
    }

    /**
     * Returns the current failure mode.
     *
     * @return string
     */
    public function getFailureMode(): string
    {
        return $this->failureMode;
    }

    /**
     * Determines if the field is a `valid` blank value.
     *
     * Values are considered blank if they are, not sent, null, or strings that trim down to nothing. integers, floats,
     * arrays, resources, objects, etc., are never considered blank. Even a value of `(int) 0` will *not* evaluate as
     * blank.
     * The optional second argument is used to supply an array of white listed items that should be considered blank.
     *
     * @param mixed $subject
     * @param array $blankWhiteList

There is no parameter named $blankWhiteList. Was it maybe removed?

     *
     * @return bool
     */
    public function subjectFieldIsBlank($subject): bool
    {
        foreach ($this->blankWhiteList as $item) {
            if ($subject->{$this->field} === $item) {
                return true;
            }
        }

        // not set, or null, means it is blank
        if (!isset($subject->{$this->field}) || $subject->{$this->field} === null) {
            return true;
        }

        // non-strings are not blank: int, float, object, array, resource, etc
        if (!is_string($subject->{$this->field})) {
            return false;
        }

        // strings that trim down to exactly nothing are blank
        return trim($subject->{$this->field}) === '';
    }

    /**
     * Returns the default failure message for this rule specification.
     *
     * @return string
     */
    protected function getDefaultMessage(): string
    {
        return $this->ruleClass . $this->argsTostring();
    }

    /**
     * Converts the args to a string.
     *
     * @return string
     */
    protected function argsTostring(): string
    {
        if (!$this->args) {

The expression $this->args of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return '()';
        }

        return '(' . implode(', ', $this->args) . ')';
    }
}