GeminiLabs\Castor\Services\Validator

Complexity

Total Complexity

62

Size/Duplication

Total Lines	557
Duplicated Lines	0 %

Importance

Changes

0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	parseParameters()	0	7	2
A	validateNumeric()	0	3	1
A	parseRule()	0	16	2
A	validateAccepted()	0	5	2
A	validateAttribute()	0	14	4
A	shouldStopValidating()	0	5	3
A	validateMin()	0	5	1
A	getSize()	0	12	4
A	replaceBetween()	0	3	1
A	translator()	0	17	4
A	getValue()	0	4	2
A	setRules()	0	9	3
A	snakeCase()	0	9	2
A	getRule()	0	11	4
A	replaceMin()	0	3	1
A	addError()	0	8	2
A	hasRule()	0	3	1
A	getMessage()	0	9	2
A	validateEmail()	0	3	1
A	getAttributeType()	0	5	2
A	validate()	0	14	4
A	validateMax()	0	5	1
A	replaceMax()	0	3	1
A	getSizeMessage()	0	8	1
A	normalizeData()	0	11	2
A	validateBetween()	0	7	2
A	requireParameterCount()	0	4	2
A	addFailure()	0	5	1
A	validateRequired()	0	8	4

<?php

namespace GeminiLabs\Castor\Services;

use BadMethodCallException;
use InvalidArgumentException;

class Validator
{
	/**
	 * @var array
	 */
	public $errors = [];

	/**
	 * The data under validation.
	 *
	 * @var array
	 */
	protected $data = [];

	/**
	 * The failed validation rules.
	 *
	 * @var array
	 */
	protected $failedRules = [];

	/**
	 * The rules to be applied to the data.
	 *
	 * @var array
	 */
	protected $rules = [];

	/**
	 * The size related validation rules.
	 *
	 * @var array
	 */
	protected $sizeRules = [
		'Between',
		'Max',
		'Min',
	];

	/**
	 * The validation rules that imply the field is required.
	 *
	 * @var array
	 */
	protected $implicitRules = [
		'Required',
	];

	/**
	 * The numeric related validation rules.
	 *
	 * @var array
	 */
	protected $numericRules = [
		'Numeric',
	];

	/**
	 * Run the validator's rules against its data.
	 *
	 * @param mixed $data
	 *
	 * @return array
	 */
	public function validate( $data, array $rules = [] )
	{
		$this->normalizeData( $data );
		$this->setRules( $rules );

		foreach( $this->rules as $attribute => $rules ) {
			foreach( $rules as $rule ) {
				$this->validateAttribute( $rule, $attribute );

				if( $this->shouldStopValidating( $attribute ))break;
			}
		}

		return $this->errors;
	}

	/**
	 * Add an error message to the validator's collection of errors.
	 *
	 * @param string $attribute
	 * @param string $rule
	 *
	 * @return void
	 */
	protected function addError( $attribute, $rule, array $parameters )
	{
		$message = $this->getMessage( $attribute, $rule, $parameters );

		$this->errors[ $attribute ]['errors'][] = $message;

		if( !isset( $this->errors[ $attribute ]['value'] )) {
			$this->errors[ $attribute ]['value'] = $this->getValue( $attribute );
		}
	}

	/**
	 * Add a failed rule and error message to the collection.
	 *
	 * @param string $attribute
	 * @param string $rule
	 *
	 * @return void
	 */
	protected function addFailure( $attribute, $rule, array $parameters )
	{
		$this->addError( $attribute, $rule, $parameters );

		$this->failedRules[ $attribute ][ $rule ] = $parameters;
	}

	/**
	 * Get the data type of the given attribute.
	 *
	 * @param  string  $attribute
	 * @return string
	 */
	protected function getAttributeType( $attribute )
	{
		return $this->hasRule( $attribute, $this->numericRules )
			? 'numeric'
			: 'string';
	}

	/**
	 * Get the validation message for an attribute and rule.
	 *
	 * @param string $attribute
	 * @param string $rule
	 *
	 * @return string|null
	 */
	protected function getMessage( $attribute, $rule, array $parameters )
	{
		if( in_array( $rule, $this->sizeRules )) {
			return $this->getSizeMessage( $attribute, $rule, $parameters );
		}

		$lowerRule = $this->snakeCase( $rule );

		return $this->translator( $lowerRule, $rule, $attribute, $parameters );
	}

	/**
	 * Get a rule and its parameters for a given attribute.
	 *
	 * @param string       $attribute
	 * @param string|array $rules
	 *
	 * @return array|null
	 */
	protected function getRule( $attribute, $rules )
	{
		if( !array_key_exists( $attribute, $this->rules ))return;

		$rules = (array) $rules;

		foreach( $this->rules[ $attribute ] as $rule ) {
			list( $rule, $parameters ) = $this->parseRule( $rule );

			if( in_array( $rule, $rules )) {
				return [ $rule, $parameters ];
			}
		}
	}

	/**
	 * Get the size of an attribute.
	 *
	 * @param string $attribute
	 * @param mixed  $value
	 *
	 * @return mixed
	 */
	protected function getSize( $attribute, $value )
	{
		$hasNumeric = $this->hasRule( $attribute, $this->numericRules );

		if( is_numeric( $value ) && $hasNumeric ) {
			return $value;
		}
		elseif( is_array( $value )) {
			return count( $value );
		}

		return mb_strlen( $value );
	}

	/**
	 * Get the proper error message for an attribute and size rule.
	 *
	 * @param string $attribute
	 * @param string $rule
	 *
	 * @return string|null
	 */
	protected function getSizeMessage( $attribute, $rule, array $parameters )
	{
		$lowerRule = $this->snakeCase( $rule );
		$type = $this->getAttributeType( $attribute );

		$lowerRule .= ".{$type}";

		return $this->translator( $lowerRule, $rule, $attribute, $parameters );
	}

	/**
	 * Get the value of a given attribute.
	 *
	 * @param string $attribute
	 *
	 * @return mixed
	 */
	protected function getValue( $attribute )
	{
		if( isset( $this->data[ $attribute ] )) {
			return $this->data[ $attribute ];
		}
	}

	/**
	 * Determine if the given attribute has a rule in the given set.
	 *
	 * @param string       $attribute
	 * @param string|array $rules
	 *
	 * @return bool
	 */
	protected function hasRule( $attribute, $rules )
	{
		return !is_null( $this->getRule( $attribute, $rules ));
	}

	/**
	 * Normalize the provided data to an array.
	 *
	 * @param mixed $data
	 *
	 * @return $this
	 */
	protected function normalizeData( $data )
	{
		// If an object was provided, get its public properties
		if( is_object( $data )) {
			$this->data = get_object_vars( $data );
		}
		else {
			$this->data = $data;
		}

		return $this;
	}

	/**
	 * Parse a parameter list.
	 *
	 * @param string $rule
	 * @param string $parameter
	 *
	 * @return array
	 */
	protected function parseParameters( $rule, $parameter )
	{
		if( strtolower( $rule ) == 'regex' ) {
			return [ $parameter ];
		}

		return str_getcsv( $parameter );
	}

	/**
	 * Extract the rule name and parameters from a rule.
	 *
	 * @param string $rule
	 *
	 * @return array
	 */
	protected function parseRule( $rule )
	{
		$parameters = [];

		// example: {rule}:{parameters}

50% of this comment could be valid code. Did you maybe forget this after debugging?

		if( strpos( $rule, ':' ) !== false ) {
			list( $rule, $parameter ) = explode( ':', $rule, 2 );

			// example: {parameter1,parameter2,...}

50% of this comment could be valid code. Did you maybe forget this after debugging?

			$parameters = $this->parseParameters( $rule, $parameter );
		}

		$rule = ucwords( str_replace( ['-', '_'], ' ', trim( $rule )));
		$rule = str_replace( ' ', '', $rule );

		return [ $rule, $parameters ];
	}

	/**
	 * Replace all placeholders for the between rule.
	 *
	 * @param string $message
	 *
	 * @return string
	 */
	protected function replaceBetween( $message, array $parameters )
	{
		return str_replace([':min', ':max'], $parameters, $message );
	}

	/**
	 * Replace all placeholders for the max rule.
	 *
	 * @param string $message
	 *
	 * @return string
	 */
	protected function replaceMax( $message, array $parameters )
	{
		return str_replace( ':max', $parameters[0], $message );
	}

	/**
	 * Replace all placeholders for the min rule.
	 *
	 * @param string $message
	 *
	 * @return string
	 */
	protected function replaceMin( $message, array $parameters )
	{
		return str_replace( ':min', $parameters[0], $message );
	}

	/**
	 * Require a certain number of parameters to be present.
	 *
	 * @param int    $count
	 * @param string $rule
	 *
	 * @return void
	 * @throws InvalidArgumentException
	 */
	protected function requireParameterCount( $count, array $parameters, $rule )
	{
		if( count( $parameters ) < $count ) {
			throw new InvalidArgumentException( "Validation rule $rule requires at least $count parameters." );
		}
	}

	/**
	 * Set the validation rules.
	 *
	 * @return $this
	 */
	protected function setRules( array $rules )
	{
		foreach( $rules as $key => $rule ) {
			$rules[ $key ] = is_string( $rule ) ? explode( '|', $rule ) : $rule;
		}

		$this->rules = $rules;

		return $this;
	}

	/**
	 * Check if we should stop further validations on a given attribute.
	 *
	 * @param string $attribute
	 *
	 * @return bool
	 */
	protected function shouldStopValidating( $attribute )
	{
		return $this->hasRule( $attribute, $this->implicitRules )
			&& isset( $this->failedRules[ $attribute ] )
			&& array_intersect( array_keys( $this->failedRules[ $attribute ] ), $this->implicitRules );
	}

	/**
	 * Convert a string to snake case.
	 *
	 * @param string $string
	 *
	 * @return string
	 */
	protected function snakeCase( $string )
	{
		if( !ctype_lower( $string )) {
			$string = preg_replace( '/\s+/u', '', $string );
			$string = preg_replace( '/(.)(?=[A-Z])/u', '$1_', $string );
			$string = mb_strtolower( $string, 'UTF-8' );
		}

		return $string;
	}

	/**
	 * Returns a translated message for the attribute
	 *
	 * @param string $key
	 * @param string $rule
	 * @param string $attribute
	 *
	 * @return string|null
	 */
	protected function translator( $key, $rule, $attribute, array $parameters )
	{
		$strings = glsr_resolve( 'Strings' )->validation();

The function glsr_resolve was not found. Maybe you did not declare it correctly or list all dependencies?

		$message = isset( $strings[ $key ] )
			? $strings[ $key ]
			: false;

		if( !$message )return;

		$message = str_replace( ':attribute', $attribute, $message );

		if( method_exists( $this, $replacer = "replace{$rule}" )) {
			$message = $this->$replacer( $message, $parameters );
		}

		return $message;
	}

	// Rules Validation
	// ---------------------------------------------------------------------------------------------

	/**
	 * Validate that an attribute was "accepted".
	 *
	 * This validation rule implies the attribute is "required".
	 *
	 * @param mixed  $value
	 *
	 * @return bool
	 */
	protected function validateAccepted( $value )
	{
		$acceptable = ['yes', 'on', '1', 1, true, 'true'];

		return $this->validateRequired( $value ) && in_array( $value, $acceptable, true );
	}

	/**
	 * Validate a given attribute against a rule.
	 *
	 * @param string $rule
	 * @param string $attribute
	 *
	 * @return void
	 * @throws BadMethodCallException
	 */
	protected function validateAttribute( $rule, $attribute )
	{
		list( $rule, $parameters ) = $this->parseRule( $rule );

		if( $rule == '' )return;

		$method = "validate{$rule}";

		if( !method_exists( $this, $method )) {
			throw new BadMethodCallException( "Method [$method] does not exist." );
		}

		if( !$this->$method( $this->getValue( $attribute ), $attribute, $parameters )) {
			$this->addFailure( $attribute, $rule, $parameters );
		}
	}

	/**
	 * Validate the size of an attribute is between a set of values.
	 *
	 * @param mixed  $value
	 * @param string $attribute
	 *
	 * @return bool
	 */
	protected function validateBetween( $value, $attribute, array $parameters )
	{
		$this->requireParameterCount( 2, $parameters, 'between' );

		$size = $this->getSize( $attribute, $value );

		return $size >= $parameters[0] && $size <= $parameters[1];
	}

	/**
	 * Validate that an attribute is a valid e-mail address.
	 *
	 * @param mixed $value
	 *
	 * @return bool
	 */
	protected function validateEmail( $value )
	{
		return filter_var( $value, FILTER_VALIDATE_EMAIL ) !== false;
	}

	/**
	 * Validate the size of an attribute is less than a maximum value.
	 *
	 * @param mixed  $value
	 * @param string $attribute
	 *
	 * @return bool
	 */
	protected function validateMax( $value, $attribute, array $parameters )
	{
		$this->requireParameterCount( 1, $parameters, 'max' );

		return $this->getSize( $attribute, $value ) <= $parameters[0];
	}

	/**
	 * Validate the size of an attribute is greater than a minimum value.
	 *
	 * @param mixed  $value
	 * @param string $attribute
	 *
	 * @return bool
	 */
	protected function validateMin( $value, $attribute, array $parameters )
	{
		$this->requireParameterCount( 1, $parameters, 'min' );

		return $this->getSize( $attribute, $value ) >= $parameters[0];
	}

	/**
	 * Validate that an attribute is numeric.
	 *
	 * @param mixed $value
	 *
	 * @return bool
	 */
	protected function validateNumeric( $value )
	{
		return is_numeric( $value );
	}

	/**
	 * Validate that a required attribute exists.
	 *
	 * @param mixed $value
	 *
	 * @return bool
	 */
	protected function validateRequired( $value )
	{
		if( is_string( $value )) {
			$value = trim( $value );
		}
		return is_null( $value ) || empty( $value )
			? false
			: true;
	}
}