Pulsar\Validator

Complexity

Total Complexity

58

Size/Duplication

Total Lines	472
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes	1
Bugs	1	Features	1

25 Methods

Rating	Name	Duplication	Size	Complexity
A	configure()	0	4	1
A	__construct()	0	12	3
C	validate()	0	28	8
A	buildRequirementsFromStr()	0	19	3
A	skipRemaining()	0	6	1
A	alpha()	0	4	2
A	alpha_numeric()	0	4	2
A	alpha_dash()	0	4	2
A	boolean()	0	6	1
A	custom()	0	7	1
A	email()	0	6	1
A	enum()	0	4	1
A	date()	0	4	1
A	ip()	0	4	1
B	matching()	0	19	5
A	numeric()	0	6	2
A	password()	0	12	3
B	range()	0	14	5
A	required()	0	4	1
A	skip_empty()	0	9	2
A	string()	0	12	4
A	time_zone()	0	14	3
A	timestamp()	0	10	2
A	db_timestamp()	0	10	2
A	url()	0	4	1

<?php

/**
 * @author Jared King <j@jaredtking.com>
 *
 * @link http://jaredtking.com
 *
 * @copyright 2015 Jared King
 * @license MIT
 */
namespace Pulsar;

use Infuse\Utility;

class Validator
{
    /**
     * @staticvar array
     */
    private static $config = [
        'salt' => '',
    ];

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

    /**
     * @var Errors
     */
    private $errors;

    /**
     * @var bool
     */
    private $skipRemaining;

    /**
     * Changes settings for the validator.
     *
     * @param array $config
     */
    public static function configure($config)
    {
        self::$config = array_replace(self::$config, (array) $config);
    }

    /**
     * @var array
     * @var Errors
     */
    public function __construct(array $requirements, Errors $errors = null)
    {
        // parse requirement strings if used
        foreach ($requirements as &$requirements2) {
            if (!is_array($requirements2)) {
                $requirements2 = $this->buildRequirementsFromStr($requirements2);
            }
        }

        $this->requirements = $requirements;
        $this->errors = $errors;
    }

    /**
     * Validates whether an input matches the requirements.
     *
     * @param array $data
     *
     * @return bool
     */
    public function validate(array &$data)
    {
        $validated = true;
        foreach ($this->requirements as $name => $requirements) {
            if (!array_key_exists($name, $data)) {
                $data[$name] = null;
            }

            $this->skipRemaining = false;

            foreach ($requirements as $requirement) {
                list($filter, $parameters) = $requirement;

                $valid = self::$filter($data[$name], $parameters);
                $validated = $validated && $valid;

                if (!$valid && $this->errors) {
                    $this->errors->add($name, "pulsar.validation.$filter");
                }

                if ($this->skipRemaining) {
                    break;
                }
            }
        }

        return $validated;
    }

    /**
     * Parses a string into a list of requirements.
     * Requirement strings have the form "numeric|range:10,30" where
     * '|' separates filters and ':' allows a comma-separated list
     * of parameters to be specified. This example would generate 
     * [['numeric', []], ['range', [10, 30]]].
     *
     * @param string $requirements

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

     *
     * @return array
     */
    private function buildRequirementsFromStr($str)
    {
        $requirements = [];

        // explodes the string into a a list of strings
        // containing filters and parameters
        $pieces = explode('|', $str);
        foreach ($pieces as $piece) {
            $exp = explode(':', $piece);
            // [0] = filter method
            $method = $exp[0];

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

            // [1] = optional method parameters
            $parameters = isset($exp[1]) ? explode(',', $exp[1]) : [];

            $requirements[] = [$exp[0], $parameters];
        }

        return $requirements;
    }

    /**
     * Skips remaining requirements.
     *
     * @return self
     */
    private function skipRemaining()
    {
        $this->skipRemaining = true;

        return $this;
    }

    ////////////////////////////////
    // FILTERS
    ////////////////////////////////

    /**
     * Validates an alpha string.
     * OPTIONAL alpha:5 can specify minimum length.
     *
     * @param mixed $value
     * @param array $parameters
     *
     * @return bool
     */
    private function alpha($value, array $parameters)

This method is not used, and could be removed.

    {
        return preg_match('/^[A-Za-z]*$/', $value) && strlen($value) >= array_value($parameters, 0);
    }

    /**
     * Validates an alpha-numeric string
     * OPTIONAL alpha_numeric:6 can specify minimum length.
     *
     * @param mixed $value
     * @param array $parameters
     *
     * @return bool
     */
    private function alpha_numeric($value, array $parameters)

This method is not used, and could be removed.

    {
        return preg_match('/^[A-Za-z0-9]*$/', $value) && strlen($value) >= array_value($parameters, 0);
    }

    /**
     * Validates an alpha-numeric string with dashes and underscores
     * OPTIONAL alpha_dash:7 can specify minimum length.
     *
     * @param mixed $value
     * @param array $parameters
     *
     * @return bool
     */
    private function alpha_dash($value, array $parameters)

This method is not used, and could be removed.

    {
        return preg_match('/^[A-Za-z0-9_-]*$/', $value) && strlen($value) >= array_value($parameters, 0);
    }

    /**
     * Validates a boolean value.
     *
     * @param mixed $value
     *
     * @return bool
     */
    private function boolean(&$value)

This method is not used, and could be removed.

    {
        $value = filter_var($value, FILTER_VALIDATE_BOOLEAN);

        return true;
    }

    /**
     * Validates by calling a given function.
     *
     * @param mixed $value
     * @param array $parameters
     *
     * @return bool
     */
    private function custom(&$value, array $parameters)

This method is not used, and could be removed.

    {
        $method = $parameters[0];
        $parameters2 = (array) array_slice($parameters, 1);

        return $method($value, $parameters2);
    }

    /**
     * Validates an e-mail address.
     *
     * @param string $email      e-mail address

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

     * @param array  $parameters parameters for validation
     *
     * @return bool success
     */
    private function email(&$value, array $parameters)

The parameter $parameters is not used and could be removed.

This method is not used, and could be removed.

    {
        $value = trim(strtolower($value));

        return filter_var($value, FILTER_VALIDATE_EMAIL);
    }

    /**
     * Validates a value exists in an array. i.e. enum:blue,red,green,yellow.
     *
     * @param mixed $value
     * @param array $parameters
     *
     * @return bool
     */
    private function enum($value, array $parameters)

This method is not used, and could be removed.

    {
        return in_array($value, $parameters);
    }

    /**
     * Validates a date string.
     *
     * @param mixed $value
     *
     * @return bool
     */
    private function date($value)

This method is not used, and could be removed.

    {
        return strtotime($value);
    }

    /**
     * Validates an IP address.
     *
     * @param mixed $value
     *
     * @return bool
     */
    private function ip($value)

This method is not used, and could be removed.

    {
        return filter_var($value, FILTER_VALIDATE_IP);
    }

    /**
     * Validates that an array of values matches. The array will
     * be flattened to a single value if it matches.
     *
     * @param mixed $value
     *
     * @return bool
     */
    private function matching(&$value)

This method is not used, and could be removed.

    {
        if (!is_array($value)) {
            return true;
        }

        $matches = true;
        $cur = reset($value);
        foreach ($value as $v) {
            $matches = ($v == $cur) && $matches;
            $cur = $v;
        }

        if ($matches) {
            $value = $cur;
        }

        return $matches;
    }

    /**
     * Validates a number.
     * OPTIONAL numeric:int specifies a type.
     *
     * @param mixed $value
     * @param array $parameters
     *
     * @return bool
     */
    private function numeric($value, array $parameters)

This method is not used, and could be removed.

    {
        $check = 'is_'.array_value($parameters, 0);

        return (!isset($parameters[0])) ? is_numeric($value) : $check($value);
    }

    /**
     * Validates a password and hashes the value.
     * OPTIONAL password:10 sets the minimum length.
     *
     * @param mixed $value
     * @param array $parameters
     *
     * @return bool
     */
    private function password(&$value, array $parameters)

This method is not used, and could be removed.

    {
        $minimumPasswordLength = (isset($parameters[0])) ? $parameters[0] : 8;

        if (strlen($value) < $minimumPasswordLength) {
            return false;
        }

        $value = Utility::encryptPassword($value, self::$config['salt']);

        return true;
    }

    /**
     * Validates that a number falls within a range.
     *
     * @param mixed $value
     * @param array $parameters
     *
     * @return bool
     */
    private function range($value, array $parameters)

This method is not used, and could be removed.

    {
        // check min
        if (isset($parameters[0]) && $value < $parameters[0]) {
            return false;
        }

        // check max
        if (isset($parameters[1]) && $value > $parameters[1]) {
            return false;
        }

        return true;
    }

    /**
     * Makes sure that a variable is not empty.
     *
     * @param mixed $value
     *
     * @return bool
     */
    private function required($value)

This method is not used, and could be removed.

    {
        return !empty($value);
    }

    /**
     * Skips any remaining requirements for a field if the
     * value is empty.
     *
     * @param mixed $value
     *
     * @return bool
     */
    public function skip_empty(&$value)
    {
        if (empty($value)) {
            $value = null;
            $this->skipRemaining();
        }

        return true;
    }

    /**
     * Validates a string.
     * OPTIONAL string:5 supplies a minimum length
     *          string:1:5 supplies a minimum and maximum length.
     *
     * @param mixed $value
     * @param array $parameters
     *
     * @return bool
     */
    private function string($value, array $parameters)

This method is not used, and could be removed.

    {
        if (!is_string($value)) {
            return false;
        }

        $len = strlen($value);
        $min = array_value($parameters, 0);
        $max = array_value($parameters, 1);

        return $len >= $min && (!$max || $len <= $max);
    }

    /**
     * Validates a PHP time zone identifier.
     *
     * @param mixed $value
     *
     * @return bool
     */
    private function time_zone($value)

This method is not used, and could be removed.

    {
        // thanks to http://stackoverflow.com/questions/5816960/how-to-check-is-timezone-identifier-valid-from-code
        $valid = [];
        $tza = timezone_abbreviations_list();
        foreach ($tza as $zone) {
            foreach ($zone as $item) {
                $valid[$item['timezone_id']] = true;
            }
        }
        unset($valid['']);

        return !!array_value($valid, $value);
    }

    /**
     * Validates a Unix timestamp. If the value is not a timestamp it will be
     * converted to one with strtotime().
     *
     * @param mixed $value
     *
     * @return bool
     */
    private function timestamp(&$value)

This method is not used, and could be removed.

    {
        if (ctype_digit((string) $value)) {
            return true;
        }

        $value = strtotime($value);

        return !!$value;
    }

    /**
     * Converts a Unix timestamp into a format compatible with database
     * timestamp types.
     *
     * @param mixed $value
     *
     * @return bool
     */
    private function db_timestamp(&$value)

This method is not used, and could be removed.

    {
        if (is_integer($value)) {
            $value = Utility::unixToDb($value);

            return true;
        }

        return false;
    }

    /**
     * Validates a URL.
     *
     * @param mixed $value
     *
     * @return bool
     */
    private function url($value)

This method is not used, and could be removed.

    {
        return filter_var($value, FILTER_VALIDATE_URL);
    }
}