TheSupportGroup\Common\Validator\Rules\BaseRule

Complexity

Total Complexity

16

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Importance

Changes	6
Bugs	3	Features	1

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	__call()	0	11	1
A	buildRule()	0	4	1
A	validate()	0	4	1
A	getConfig()	0	8	3
A	hasRule()	0	4	1
B	isNotRequiredAndEmpty()	0	15	5
A	setParams()	0	6	1
A	getParams()	0	4	1
A	getRuleName()	0	6	1
	getMessage()	0	1	?
	isValid()	0	1	?

<?php

/**
 * @author: Abdul Qureshi. <abdul@easyfundraising.org.uk>
 * 
 * This file has been modified from the original source.
 * See original here:
 *
 * @link: https://github.com/progsmile/request-validator
 */
namespace TheSupportGroup\Common\Validator\Rules;

use TheSupportGroup\Common\ValidationInterop\ValidationProviderInterface;

abstract class BaseRule
{
    const CONFIG_ALL = 'all';
    const CONFIG_DATA = 'data';
    const CONFIG_FIELD_RULES = 'fieldRules';

    /**
     * @var array $config
     */
    private $config;

    /**
     * @var array $params
     */
    private $params;

    /**
     * @var ValidationProviderInterface $validationProvider
     */
    private $validationProvider;

    /**
     * BaseRule constructor.
     *
     * @param $config
     */
    public function __construct(
        $config,
        ValidationProviderInterface $validationProvider
    ) {
        $this->config = $config;
        $this->validationProvider = $validationProvider;
    }

    /**
     * Validator calls captured and remapped here.
     *
     * @return BaseRule Validator rule object.
     */
    public function __call($method, array $params = array())
    {
        // Get the mapping out of the mapper file.
        $validatorMethod = $this->validationProvider->getMappedMethod($method);

        // Try running rule against params.
        $this->buildRule($validatorMethod, $params);

        // Return self for next call to be made via the base Rule.
        return $this;
    }

    /**
     * Run rule against validator.
     */
    private function buildRule($ruleName, $arguments = [])

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->validationProvider->rule($ruleName, $arguments);
    }

    /**
     * Validate rule against value provided.
     * We can control which method is called on the external library.
     */
    public function validate($value)

The return type could not be reliably inferred; please add a @return annotation.

    {
        return $this->validationProvider->validate($value);
    }

    /**
     * Returns all config array, or specific one.
     *
     * @param string $type
     *
     * @return string
     */
    public function getConfig($type = self::CONFIG_ALL)
    {
        if ($type == self::CONFIG_ALL) {
            return $this->config;
        }

        return isset($this->config[$type]) ? $this->config[$type] : [];
    }

    /**
     * If field has specific rule.
     *
     * @param string $rule
     *
     * @return bool
     */
    public function hasRule($rule)
    {
        return strpos($this->getConfig(self::CONFIG_FIELD_RULES), $rule) !== false;
    }

    /**
     * Check if variable is not required - to prevent error messages from another validators.
     *
     * @param string $type | 'var' or 'file'
     *
     * @return bool
     */
    protected function isNotRequiredAndEmpty($type = 'var')

isNotRequiredAndEmpty uses the super-global variable $_FILES which is generally not recommended.

    {
        $condition = false;

        if ($type == 'var') {
            $condition = strlen($this->params[1]) == 0;
        } elseif ($type == 'file') {
            $fieldsName = $this->params[0];

            //when file field is not required and empty
            $condition = isset($_FILES[$fieldsName]['name']) && $_FILES[$fieldsName]['name'] == '';
        }

        return !$this->hasRule('required') && $condition;
    }

    /**
     * Set params to validator.
     *
     * @param $params
     *
     * @return $this
     */
    public function setParams($params)
    {
        $this->params = $params;

        return $this;
    }

    /**
     * Returns params.
     *
     * @return mixed
     */
    public function getParams()
    {
        return $this->params;
    }

    /**
     * Returns pure class name.
     *
     * @return string
     */
    public function getRuleName()
    {
        $classPath = explode('\\', get_class($this));

        return array_pop($classPath);
    }

    /**
     * Returns error message from rule.
     *
     * @return string
     */
    abstract public function getMessage();

    /**
     * The main function that validates the inputted value against
     * an existing one or similar.
     *
     * @return bool Return a if values were valid/matched or not
     */
    abstract public function isValid();
}