Validation_Core::chars() - Code Metrics - vijinho/kohana2-legacy - Measure and Improve Code Quality continuously with Scrutinizer

Validation_Core::chars() A
last analyzed 2016-08-25 15:53 UTC

↳ Parent: Validation_Core
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	1	Features	0
Metric	Value
cc	1
eloc	2
c	2
b	1
f	0
nc	1
nop	2
dl	0
loc	4
rs	10
<?php defined('SYSPATH') or die('No direct access allowed.');
/**
 * Validation library.
 *
 * $Id: Validation.php 4120 2009-03-25 19:22:31Z jheathco $
 *
 * @package    Validation
 * @author     Kohana Team
 * @copyright  (c) 2007-2008 Kohana Team
 * @license    http://kohanaphp.com/license.html
 */
class Validation_Core extends ArrayObject
{

    // Filters
    protected $pre_filters = array();
    protected $post_filters = array();

    // Rules and callbacks
    protected $rules = array();
    protected $callbacks = array();

    // Rules that are allowed to run on empty fields
    protected $empty_rules = array('required', 'matches');

    // Errors
    protected $errors = array();
    protected $messages = array();

    // Fields that are expected to be arrays
    protected $array_fields = array();

    // Checks if there is data to validate.
    protected $submitted;

    /**
     * Creates a new Validation instance.
     *
     * @param   array   array to use for validation
     * @return  object

     */
    public static function factory(array $array)
    {
        return new Validation($array);
    }

    /**
     * Sets the unique "any field" key and creates an ArrayObject from the
     * passed array.
     *
     * @param   array   array to validate
     * @return  void

     */
    public function __construct(array $array)
    {
        // The array is submitted if the array is not empty
        $this->submitted = ! empty($array);

        parent::__construct($array, ArrayObject::ARRAY_AS_PROPS | ArrayObject::STD_PROP_LIST);
    }

    /**
     * Magic clone method, clears errors and messages.
     *
     * @return  void
     */
    public function __clone()
    {
        $this->errors = array();
        $this->messages = array();
    }

    /**
     * Create a copy of the current validation rules and change the array.
     *
     * @chainable
     * @param   array  new array to validate

     * @return  Validation_Core
     */
    public function copy(array $array)
    {
        $copy = clone $this;

        $copy->exchangeArray($array);

        return $copy;
    }

    /**
     * Test if the data has been submitted.
     *
     * @return  boolean
     */
    public function submitted($value = null)
    {
        if (is_bool($value)) {
            $this->submitted = $value;
        }

        return $this->submitted;
    }

    /**
     * Returns an array of all the field names that have filters, rules, or callbacks.
     *
     * @return  array

     */
    public function field_names()
    {
        // All the fields that are being validated
        $fields = array_keys(array_merge(
            $this->pre_filters,
            $this->rules,
            $this->callbacks,
            $this->post_filters
        ));

        // Remove wildcard fields
        $fields = array_diff($fields, array('*'));

        return $fields;
    }

    /**
     * Returns the array values of the current object.
     *
     * @return  array
     */
    public function as_array()
    {
        return $this->getArrayCopy();
    }

    /**
     * Returns the ArrayObject values, removing all inputs without rules.
     * To choose specific inputs, list the field name as arguments.
     *
     * @param   boolean  return only fields with filters, rules, and callbacks
     * @return  array
     */
    public function safe_array()
    {
        // Load choices
        $choices = func_get_args();
        $choices = empty($choices) ? null : array_combine($choices, $choices);

        // Get field names
        $fields = $this->field_names();

        $safe = array();
        foreach ($fields as $field) {
            if ($choices === null or isset($choices[$field])) {
                if (isset($this[$field])) {
                    $value = $this[$field];

                    if (is_object($value)) {
                        // Convert the value back into an array
                        $value = $value->getArrayCopy();
                    }
                } else {
                    // Even if the field is not in this array, it must be set
                    $value = null;
                }

                // Add the field to the array
                $safe[$field] = $value;
            }
        }

        return $safe;
    }

    /**
     * Add additional rules that will forced, even for empty fields. All arguments
     * passed will be appended to the list.
     *
     * @chainable
     * @param   string   rule name
     * @return  Validation_Core
     */
    public function allow_empty_rules($rules)

    {
        // Any number of args are supported
        $rules = func_get_args();

        // Merge the allowed rules
        $this->empty_rules = array_merge($this->empty_rules, $rules);

        return $this;
    }

    /**
     * Converts a filter, rule, or callback into a fully-qualified callback array.
     *
     * @return  callable
     */
    protected function callback($callback)
    {
        if (is_string($callback)) {
            if (strpos($callback, '::') !== false) {
                $callback = explode('::', $callback);
            } elseif (function_exists($callback)) {
                // No need to check if the callback is a method
                $callback = $callback;

            } elseif (method_exists($this, $callback)) {
                // The callback exists in Validation
                $callback = array($this, $callback);
            } elseif (method_exists('valid', $callback)) {
                // The callback exists in valid::
                $callback = array('valid', $callback);
            }
        }

        if (! is_callable($callback, false)) {
            if (is_array($callback)) {
                if (is_object($callback[0])) {
                    // Object instance syntax
                    $name = get_class($callback[0]).'->'.$callback[1];
                } else {
                    // Static class syntax
                    $name = $callback[0].'::'.$callback[1];
                }
            } else {
                // Function syntax
                $name = $callback;
            }

            throw new Kohana_Exception('validation.not_callable', $name);
        }

        return $callback;
    }

    /**
     * Add a pre-filter to one or more inputs. Pre-filters are applied before
     * rules or callbacks are executed.
     *
     * @chainable
     * @param   callback  filter
     * @param   string    fields to apply filter to, use TRUE for all fields
     * @return  Validation_Core
     */
    public function pre_filter($filter, $field = true)

    {
        if ($field === true or $field === '*') {
            // Use wildcard
            $fields = array('*');
        } else {
            // Add the filter to specific inputs
            $fields = func_get_args();
            $fields = array_slice($fields, 1);
        }

        // Convert to a proper callback
        $filter = $this->callback($filter);

        foreach ($fields as $field) {
            // Add the filter to specified field
            $this->pre_filters[$field][] = $filter;
        }

        return $this;
    }

    /**
     * Add a post-filter to one or more inputs. Post-filters are applied after
     * rules and callbacks have been executed.
     *
     * @chainable
     * @param   callback  filter
     * @param   string    fields to apply filter to, use TRUE for all fields
     * @return  Validation_Core
     */
    public function post_filter($filter, $field = true)

    {
        if ($field === true) {
            // Use wildcard
            $fields = array('*');
        } else {
            // Add the filter to specific inputs
            $fields = func_get_args();
            $fields = array_slice($fields, 1);
        }

        // Convert to a proper callback
        $filter = $this->callback($filter);

        foreach ($fields as $field) {
            // Add the filter to specified field
            $this->post_filters[$field][] = $filter;
        }

        return $this;
    }

    /**
     * Add rules to a field. Validation rules may only return TRUE or FALSE and
     * can not manipulate the value of a field.
     *
     * @chainable
     * @param   string    field name
     * @param   callback  rules (one or more arguments)
     * @return  Validation_Core
     */
    public function add_rules($field, $rules)

    {
        // Get the rules
        $rules = func_get_args();
        $rules = array_slice($rules, 1);

        if ($field === true) {
            // Use wildcard
            $field = '*';
        }

        foreach ($rules as $rule) {
            // Arguments for rule
            $args = null;

            if (is_string($rule)) {
                if (preg_match('/^([^\[]++)\[(.+)\]$/', $rule, $matches)) {
                    // Split the rule into the function and args
                    $rule = $matches[1];
                    $args = preg_split('/(?<!\\\\),\s*/', $matches[2]);

                    // Replace escaped comma with comma
                    $args = str_replace('\,', ',', $args);
                }
            }

            if ($rule === 'is_array') {
                // This field is expected to be an array
                $this->array_fields[$field] = $field;
            }

            // Convert to a proper callback
            $rule = $this->callback($rule);

            // Add the rule, with args, to the field
            $this->rules[$field][] = array($rule, $args);
        }

        return $this;
    }

    /**
     * Add callbacks to a field. Callbacks must accept the Validation object
     * and the input name. Callback returns are not processed.
     *
     * @chainable
     * @param   string     field name
     * @param   callbacks  callbacks (unlimited number)
     * @return  Validation_Core
     */
    public function add_callbacks($field, $callbacks)

    {
        // Get all callbacks as an array
        $callbacks = func_get_args();
        $callbacks = array_slice($callbacks, 1);

        if ($field === true) {
            // Use wildcard
            $field = '*';
        }

        foreach ($callbacks as $callback) {
            // Convert to a proper callback
            $callback = $this->callback($callback);

            // Add the callback to specified field
            $this->callbacks[$field][] = $callback;
        }

        return $this;
    }

    /**
     * Validate by processing pre-filters, rules, callbacks, and post-filters.
     * All fields that have filters, rules, or callbacks will be initialized if
     * they are undefined. Validation will only be run if there is data already
     * in the array.
     *
     * @param   object  Validation object, used only for recursion

     * @param   object  name of field for errors
     * @return  bool
     */
    public function validate($object = null, $field_name = null)

    {
        if ($object === null) {
            // Use the current object
            $object = $this;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        }

        // Get all field names
        $fields = $this->field_names();

        // Copy the array from the object, to optimize multiple sets
        $array = $this->getArrayCopy();

        foreach ($fields as $field) {
            if ($field === '*') {
                // Ignore wildcard
                continue;
            }

            if (! isset($array[$field])) {
                if (isset($this->array_fields[$field])) {
                    // This field must be an array
                    $array[$field] = array();
                } else {
                    $array[$field] = null;
                }
            }
        }

        // Swap the array back into the object
        $this->exchangeArray($array);

        // Get all defined field names
        $fields = array_keys($array);

        foreach ($this->pre_filters as $field => $callbacks) {

            foreach ($callbacks as $callback) {
                if ($field === '*') {
                    foreach ($fields as $f) {
                        $this[$f] = is_array($this[$f]) ? array_map($callback, $this[$f]) : call_user_func($callback, $this[$f]);
                    }
                } else {
                    $this[$field] = is_array($this[$field]) ? array_map($callback, $this[$field]) : call_user_func($callback, $this[$field]);
                }
            }
        }

        if ($this->submitted === false) {
            return false;
        }

        foreach ($this->rules as $field => $callbacks) {
            foreach ($callbacks as $callback) {
                // Separate the callback and arguments
                list($callback, $args) = $callback;

                // Function or method name of the rule
                $rule = is_array($callback) ? $callback[1] : $callback;

                if ($field === '*') {
                    foreach ($fields as $f) {
                        // Note that continue, instead of break, is used when
                        // applying rules using a wildcard, so that all fields
                        // will be validated.

                        if (isset($this->errors[$f])) {
                            // Prevent other rules from being evaluated if an error has occurred
                            continue;
                        }

                        if (empty($this[$f]) and ! in_array($rule, $this->empty_rules)) {
                            // This rule does not need to be processed on empty fields
                            continue;
                        }

                        if ($args === null) {

                            if (! call_user_func($callback, $this[$f])) {
                                $this->errors[$f] = $rule;

                                // Stop validating this field when an error is found
                                continue;
                            }
                        } else {
                            if (! call_user_func($callback, $this[$f], $args)) {
                                $this->errors[$f] = $rule;

                                // Stop validating this field when an error is found
                                continue;
                            }
                        }
                    }
                } else {
                    if (isset($this->errors[$field])) {
                        // Prevent other rules from being evaluated if an error has occurred
                        break;
                    }

                    if (! in_array($rule, $this->empty_rules) and ! $this->required($this[$field])) {
                        // This rule does not need to be processed on empty fields
                        continue;
                    }

                    if ($args === null) {

                        if (! call_user_func($callback, $this[$field])) {
                            $this->errors[$field] = $rule;

                            // Stop validating this field when an error is found
                            break;
                        }
                    } else {
                        if (! call_user_func($callback, $this[$field], $args)) {
                            $this->errors[$field] = $rule;

                            // Stop validating this field when an error is found
                            break;
                        }
                    }
                }
            }
        }

        foreach ($this->callbacks as $field => $callbacks) {
            foreach ($callbacks as $callback) {
                if ($field === '*') {
                    foreach ($fields as $f) {
                        // Note that continue, instead of break, is used when
                        // applying rules using a wildcard, so that all fields
                        // will be validated.

                        if (isset($this->errors[$f])) {
                            // Stop validating this field when an error is found
                            continue;
                        }

                        call_user_func($callback, $this, $f);
                    }
                } else {
                    if (isset($this->errors[$field])) {
                        // Stop validating this field when an error is found
                        break;
                    }

                    call_user_func($callback, $this, $field);
                }
            }
        }

        foreach ($this->post_filters as $field => $callbacks) {

            foreach ($callbacks as $callback) {
                if ($field === '*') {
                    foreach ($fields as $f) {
                        $this[$f] = is_array($this[$f]) ? array_map($callback, $this[$f]) : call_user_func($callback, $this[$f]);
                    }
                } else {
                    $this[$field] = is_array($this[$field]) ? array_map($callback, $this[$field]) : call_user_func($callback, $this[$field]);
                }
            }
        }

        // Return TRUE if there are no errors
        return $this->errors === array();
    }

    /**
     * Add an error to an input.
     *
     * @chainable
     * @param   string  input name
     * @param   string  unique error name
     * @return  Validation_Core
     */
    public function add_error($field, $name)
    {
        $this->errors[$field] = $name;

        return $this;
    }

    /**
     * Sets or returns the message for an input.
     *
     * @chainable
     * @param   string   input key
     * @param   string   message to set
     * @return  string|object
     */
    public function message($input = null, $message = null)
    {
        if ($message === null) {
            if ($input === null) {
                $messages = array();
                $keys     = array_keys($this->messages);

                foreach ($keys as $input) {
                    $messages[] = $this->message($input);
                }

                return implode("\n", $messages);
            }

            // Return nothing if no message exists
            if (empty($this->messages[$input])) {
                return '';
            }

            // Return the HTML message string
            return $this->messages[$input];
        } else {
            $this->messages[$input] = $message;
        }

        return $this;
    }

    /**
     * Return the errors array.
     *
     * @param   boolean  load errors from a lang file
     * @return  array
     */
    public function errors($file = null)
    {
        if ($file === null) {
            return $this->errors;
        } else {
            $errors = array();
            foreach ($this->errors as $input => $error) {
                // Key for this input error
                $key = "$file.$input.$error";

                if (($errors[$input] = Kohana::lang($key)) === $key) {
                    // Get the default error message
                    $errors[$input] = Kohana::lang("$file.$input.default");
                }
            }

            return $errors;
        }
    }

    /**
     * Rule: required. Generates an error if the field has an empty value.
     *
     * @param   mixed   input value
     * @return  bool
     */
    public function required($str)
    {
        if (is_object($str) and $str instanceof ArrayObject) {
            // Get the array from the ArrayObject
            $str = $str->getArrayCopy();
        }

        if (is_array($str)) {
            return ! empty($str);
        } else {
            return ! ($str === '' or $str === null or $str === false);
        }
    }

    /**
     * Rule: matches. Generates an error if the field does not match one or more
     * other fields.
     *
     * @param   mixed   input value
     * @param   array   input names to match against
     * @return  bool
     */
    public function matches($str, array $inputs)
    {
        foreach ($inputs as $key) {
            if ($str !== (isset($this[$key]) ? $this[$key] : null)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Rule: length. Generates an error if the field is too long or too short.
     *
     * @param   mixed   input value
     * @param   array   minimum, maximum, or exact length to match
     * @return  bool
     */
    public function length($str, array $length)
    {
        if (! is_string($str)) {
            return false;
        }

        $size = utf8::strlen($str);
        $status = false;

        if (count($length) > 1) {
            list($min, $max) = $length;

            if ($size >= $min and $size <= $max) {
                $status = true;
            }
        } else {
            $status = ($size === (int) $length[0]);
        }

        return $status;
    }

    /**
     * Rule: depends_on. Generates an error if the field does not depend on one
     * or more other fields.
     *
     * @param   mixed   field name
     * @param   array   field names to check dependency
     * @return  bool
     */
    public function depends_on($field, array $fields)

    {
        foreach ($fields as $depends_on) {
            if (! isset($this[$depends_on]) or $this[$depends_on] == null) {
                return false;
            }
        }

        return true;
    }

    /**
     * Rule: chars. Generates an error if the field contains characters outside of the list.
     *
     * @param   string  field value
     * @param   array   allowed characters
     * @return  bool
     */
    public function chars($value, array $chars)
    {
        return ! preg_match('![^'.implode('', $chars).']!u', $value);
    }
} // End Validation

vijinho / kohana2-legacy

Validation_Core::chars() A last analyzed 2016-08-25 15:53 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Validation_Core::chars() A
last analyzed 2016-08-25 15:53 UTC
