From 454157a343ced247bb70d5b28e76e618cb4e8edd Mon Sep 17 00:00:00 2001
From: Filis Futsarov <filisfutsarov@gmail.com>
Date: Mon, 9 Mar 2020 15:32:59 +0100
Subject: [PATCH 1/9] Make rules delimiters globally configurable

---
 gump.class.php | 55 +++++++++++++++++++++++---------------------------
 1 file changed, 25 insertions(+), 30 deletions(-)

diff --git a/gump.class.php b/gump.class.php
index 6d4652f1..c6c4595d 100644
--- a/gump.class.php
+++ b/gump.class.php
@@ -53,6 +53,15 @@ public static function get_instance()
         return self::$instance;
     }
 
+    // ** ------------------------- Configuration -------------------------------- ** //
+
+    public static $rules_delimiter = '|';
+
+    public static $rules_parameters_delimiter = ',';
+
+    public static $rules_parameters_arrays_delimiter = ';';
+
+
     // ** ------------------------- Validation Data ------------------------------- ** //
 
     public static $basic_tags = '<br><p><a><strong><b><i><em><img><blockquote><code><dd><dl><hr><h1><h2><h3><h4><h5><h6><label><ul><li><span><sub><sup>';
@@ -265,20 +274,17 @@ public function filter_rules(array $rules = [])
      *
      * @param array  $data
      * @param bool   $check_fields
-     * @param string $rules_delimiter
-     * @param string $parameters_delimiters
      *
      * @return array
      *
      * @throws Exception
      */
-    public function run(array $data, $check_fields = false, $rules_delimiter='|', $parameters_delimiters=',')
+    public function run(array $data, $check_fields = false)
     {
-        $data = $this->filter($data, $this->filter_rules(), $rules_delimiter, $parameters_delimiters);
+        $data = $this->filter($data, $this->filter_rules());
 
         $validated = $this->validate(
-            $data, $this->validation_rules(),
-            $rules_delimiter, $parameters_delimiters
+            $data, $this->validation_rules()
         );
 
         if ($check_fields === true) {
@@ -372,21 +378,19 @@ public function errors()
      *
      * @param mixed  $input
      * @param array  $ruleset
-     * @param string $rules_delimiter
-     * @param string $parameters_delimiter
      *
      * @return mixed
      *
      * @throws Exception
      */
-    public function validate(array $input, array $ruleset, string $rules_delimiter='|', string $parameters_delimiter=',')
+    public function validate(array $input, array $ruleset)
     {
         $this->errors = [];
 
         foreach ($ruleset as $field => $rawRules) {
             $input[$field] = $input[$field] ?? null;
 
-            $rules = $this->parse_rules($rawRules, $rules_delimiter);
+            $rules = $this->parse_rules($rawRules);
             $is_required = $this->field_has_required_rules($rules);
 
             if (!$is_required && self::is_empty($input[$field])) {
@@ -394,7 +398,7 @@ public function validate(array $input, array $ruleset, string $rules_delimiter='
             }
 
             foreach ($rules as $rule) {
-                $parsed_rule = $this->parse_rule($rule, $parameters_delimiter);
+                $parsed_rule = $this->parse_rule($rule);
                 $result = $this->call_rule($parsed_rule['rule'], $field, $input, $parsed_rule['param']);
 
                 if (is_array($result)) {
@@ -411,10 +415,9 @@ public function validate(array $input, array $ruleset, string $rules_delimiter='
      * Parses filters and validators rules group.
      *
      * @param string|array $rules
-     * @param string $rules_delimiter
      * @return array
      */
-    private function parse_rules($rules, string $rules_delimiter)
+    private function parse_rules($rules)
     {
         // v2
         if (is_array($rules)) {
@@ -432,17 +435,16 @@ private function parse_rules($rules, string $rules_delimiter)
             }, $rules, $rules_names);
         }
 
-        return explode($rules_delimiter, $rules);;
+        return explode(self::$rules_delimiter, $rules);;
     }
 
     /**
      * Parses filters and validators individual rules.
      *
      * @param string|array $rule
-     * @param string $parameters_delimiter
      * @return array
      */
-    private function parse_rule($rule, string $parameters_delimiter)
+    private function parse_rule($rule)
     {
         // v2
         if (is_array($rule)) {
@@ -457,8 +459,8 @@ private function parse_rule($rule, string $parameters_delimiter)
             'param' => null
         ];
 
-        if (strstr($rule, $parameters_delimiter) !== false) {
-            list($rule, $param) = explode($parameters_delimiter, $rule);
+        if (strstr($rule, self::$rules_parameters_delimiter) !== false) {
+            list($rule, $param) = explode(self::$rules_parameters_delimiter, $rule);
 
             $result['rule'] = $rule;
             $result['param'] = $this->parse_rule_param($param);
@@ -473,16 +475,12 @@ private function parse_rule($rule, string $parameters_delimiter)
      */
     private function parse_rule_param($param)
     {
-        if (is_null($param)) {
-            return null;
-        }
-
         if (is_array($param)) {
             return $param;
         }
 
-        if (strstr($param, ';') !== false) {
-            return explode(';', $param);
+        if (strstr($param, self::$rules_parameters_arrays_delimiter) !== false) {
+            return explode(self::$rules_parameters_arrays_delimiter, $param);
         }
 
         return $param;
@@ -736,28 +734,25 @@ private function process_error_message($field, $param, string $message, callable
 
     /**
      * Filter the input data according to the specified filter set.
-     * If any filter's parameter contains either '|' or ',', the corresponding default separator can be changed.
      *
      * @param mixed  $input
      * @param array  $filterset
-     * @param string $filters_delimeter
-     * @param string $parameters_delimiter
      *
      * @return mixed
      *
      * @throws Exception
      */
-    public function filter(array $input, array $filterset, string $filters_delimeter='|', string $parameters_delimiter=',')
+    public function filter(array $input, array $filterset)
     {
         foreach ($filterset as $field => $filters) {
             if (!array_key_exists($field, $input)) {
                 continue;
             }
 
-            $filters = $this->parse_rules($filters, $filters_delimeter);
+            $filters = $this->parse_rules($filters);
 
             foreach ($filters as $filter) {
-                $parsed_rule = $this->parse_rule($filter, $parameters_delimiter);
+                $parsed_rule = $this->parse_rule($filter);
 
                 if (is_array($input[$field])) {
                     $input_array = &$input[$field];

From 3d0223c3eab5f2d58a57bd14d965a8b6b8841830 Mon Sep 17 00:00:00 2001
From: Filis Futsarov <filisfutsarov@gmail.com>
Date: Mon, 9 Mar 2020 15:41:19 +0100
Subject: [PATCH 2/9] Add configuration tests

---
 tests/RunTest.php      |  1 -
 tests/ValidateTest.php | 25 ++++++++++++++++++++++++-
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/tests/RunTest.php b/tests/RunTest.php
index bc61f8bf..fa41d541 100644
--- a/tests/RunTest.php
+++ b/tests/RunTest.php
@@ -75,5 +75,4 @@ public function testOnSuccessReturnsArrayWithFiltersAppliedWithCheckFieldsSet()
             'param' => null
         ]], $this->gump->errors());
     }
-
 }
\ No newline at end of file
diff --git a/tests/ValidateTest.php b/tests/ValidateTest.php
index 7cd23a03..012f1e27 100644
--- a/tests/ValidateTest.php
+++ b/tests/ValidateTest.php
@@ -12,6 +12,30 @@
  */
 class ValidateTest extends BaseTestCase
 {
+    public function testConfigParameters()
+    {
+        $current_rules_delimiter =  GUMP::$rules_delimiter;
+        $current_rules_parameters_delimiter =  GUMP::$rules_parameters_delimiter;
+        $current_rules_parameters_arrays_delimiter =  GUMP::$rules_parameters_arrays_delimiter;
+
+        GUMP::$rules_delimiter = ';';
+        GUMP::$rules_parameters_delimiter = ':';
+        GUMP::$rules_parameters_arrays_delimiter = ',';
+
+        $result = $this->gump->validate([
+            'some_field' => 'no'
+        ], [
+            'some_field' => 'alpha;contains_list:yes,no',
+        ]);
+
+        $this->assertTrue($result);
+
+        // reset
+        GUMP::$rules_delimiter = $current_rules_delimiter;
+        GUMP::$rules_parameters_delimiter = $current_rules_parameters_delimiter;
+        GUMP::$rules_parameters_arrays_delimiter = $current_rules_parameters_arrays_delimiter;
+    }
+
     public function testIntegratedValidatorReturnsOneErrorOnOneFailure()
     {
         $result = $this->gump->validate([
@@ -323,7 +347,6 @@ public function testRulesArrayFormatWithOneParameter()
         ]], $result);
     }
 
-
     public function testRulesArrayFormatIgnoresNonRequiredFields()
     {
         $result = $this->gump->validate([

From 337b03d1c92977c9d3108b46e461f1eb73b2c1b7 Mon Sep 17 00:00:00 2001
From: Filis Futsarov <filisfutsarov@gmail.com>
Date: Mon, 9 Mar 2020 16:33:12 +0100
Subject: [PATCH 3/9] Add custom errors field/rule

---
 gump.class.php               | 16 +++++++++-------
 tests/GetErrorsArrayTest.php | 18 ++++++++++++++++++
 2 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/gump.class.php b/gump.class.php
index c6c4595d..d28e158e 100644
--- a/gump.class.php
+++ b/gump.class.php
@@ -61,7 +61,6 @@ public static function get_instance()
 
     public static $rules_parameters_arrays_delimiter = ';';
 
-
     // ** ------------------------- Validation Data ------------------------------- ** //
 
     public static $basic_tags = '<br><p><a><strong><b><i><em><img><blockquote><code><dd><dl><hr><h1><h2><h3><h4><h5><h6><label><ul><li><span><sub><sup>';
@@ -83,6 +82,8 @@ public static function get_instance()
 
     protected $lang;
 
+    protected $custom_messages = [];
+
 
     // ** ------------------------- Validation Helpers ---------------------------- ** //
 
@@ -376,16 +377,16 @@ public function errors()
      * Perform data validation against the provided ruleset.
      * If any rule's parameter contains either '|' or ',', the corresponding default separator can be changed
      *
-     * @param mixed  $input
-     * @param array  $ruleset
-     *
+     * @param mixed $input
+     * @param array $ruleset
+     * @param array $custom_messages
      * @return mixed
-     *
      * @throws Exception
      */
-    public function validate(array $input, array $ruleset)
+    public function validate(array $input, array $ruleset, array $custom_messages = [])
     {
         $this->errors = [];
+        $this->custom_messages = $custom_messages;
 
         foreach ($ruleset as $field => $rawRules) {
             $input[$field] = $input[$field] ?? null;
@@ -694,7 +695,8 @@ public function get_errors_array(bool $convert_to_string = false)
                 throw new Exception('Rule "'.$e['rule'].'" does not have an error message');
             }
 
-            $result[$e['field']] = $this->process_error_message($e['field'], $e['param'], $messages[$e['rule']]);
+            $message = $this->custom_messages[$e['field']][str_replace('validate_', '', $e['rule'])] ?? $messages[$e['rule']];
+            $result[$e['field']] = $this->process_error_message($e['field'], $e['param'], $message);
         }
 
         return $result;
diff --git a/tests/GetErrorsArrayTest.php b/tests/GetErrorsArrayTest.php
index 94301d0c..81bfe549 100644
--- a/tests/GetErrorsArrayTest.php
+++ b/tests/GetErrorsArrayTest.php
@@ -137,4 +137,22 @@ public function testItThrowsExceptionWhenCustomValidatorFailsWithoutAnErrorMessa
 
         $this->gump->get_errors_array();
     }
+
+    public function testCustomErrorMessages()
+    {
+        $this->gump->validate([
+            'test_number' => '123'
+        ], [
+            'test_number' => 'required|between_len,1;2'
+        ], [
+            'test_number' => [
+                'required' => 'Test Number can not be empty. Please fill it up.',
+                'between_len' => '{field} length MUST be between {param[0]} and {param[1]} !!!'
+            ]
+        ]);
+
+        $this->assertEquals([
+            'test_number' => 'Test Number length MUST be between 1 and 2 !!!'
+        ], $this->gump->get_errors_array());
+    }
 }
\ No newline at end of file

From 3eeca8f675f262fbe35ec85fb8c8256de1226fe8 Mon Sep 17 00:00:00 2001
From: Filis Futsarov <filisfutsarov@gmail.com>
Date: Mon, 9 Mar 2020 21:14:07 +0100
Subject: [PATCH 4/9] Update

---
 gump.class.php                  | 124 +++++++++++++++++---------------
 tests/GetErrorsArrayTest.php    |  16 +----
 tests/GetReadableErrorsTest.php |  17 +++++
 tests/StaticIsValidTest.php     |   4 +-
 4 files changed, 90 insertions(+), 71 deletions(-)

diff --git a/gump.class.php b/gump.class.php
index d28e158e..cd0e44e3 100644
--- a/gump.class.php
+++ b/gump.class.php
@@ -15,15 +15,6 @@ class GUMP
     // Singleton instance of GUMP
     protected static $instance = null;
 
-    // Validation rules for execution
-    protected $validation_rules = [];
-
-    // Filter rules for execution
-    protected $filter_rules = [];
-
-    // Instance attribute containing errors from last run
-    protected $errors = [];
-
     // Contain readable field names that have been set manually
     protected static $fields = [];
 
@@ -82,7 +73,16 @@ public static function get_instance()
 
     protected $lang;
 
-    protected $custom_messages = [];
+    protected $fields_error_messages = [];
+
+    // Validation rules for execution
+    protected $validation_rules = [];
+
+    // Filter rules for execution
+    protected $filter_rules = [];
+
+    // Instance attribute containing errors from last run
+    protected $errors = [];
 
 
     // ** ------------------------- Validation Helpers ---------------------------- ** //
@@ -103,17 +103,18 @@ public function __construct(string $lang = 'en')
      *
      * @param array $data The data to be validated
      * @param array $validators The GUMP validators
+     * @param array $fields_error_messages
      * @return mixed True(boolean) or the array of error messages
      * @throws Exception If validation rule does not exist
      */
-    public static function is_valid(array $data, array $validators)
+    public static function is_valid(array $data, array $validators, array $fields_error_messages = [])
     {
         $gump = self::get_instance();
-
         $gump->validation_rules($validators);
+        $gump->set_fields_error_messages($fields_error_messages);
 
-        if ($gump->run($data) === false) {
-            return $gump->get_readable_errors(false);
+        if ($gump->run($data, false) === false) {
+            return $gump->get_readable_errors();
         }
 
         return true;
@@ -177,11 +178,11 @@ public static function is_empty($value)
     /**
      * Adds a custom validation rule using a callback function.
      *
-     * @param string   $rule
+     * @param string $rule
      * @param callable $callback
-     * @param string   $error_message optional for backwards compatibility
+     * @param string $error_message
      *
-     * @return bool
+     * @return void
      *
      * @throws Exception
      */
@@ -196,17 +197,15 @@ public static function add_validator(string $rule, callable $callback, string $e
         if ($error_message) {
             self::$validation_methods_errors[$rule] = $error_message;
         }
-
-        return true;
     }
 
     /**
      * Adds a custom filter using a callback function.
      *
-     * @param string   $rule
+     * @param string $rule
      * @param callable $callback
      *
-     * @return bool
+     * @return void
      *
      * @throws Exception
      */
@@ -217,8 +216,6 @@ public static function add_filter(string $rule, callable $callback)
         }
 
         self::$filter_methods[$rule] = $callback;
-
-        return true;
     }
 
     /**
@@ -242,7 +239,6 @@ public static function field($key, array $array, $default = null)
      * Getter/Setter for the validation rules.
      *
      * @param array $rules
-     *
      * @return array
      */
     public function validation_rules(array $rules = [])
@@ -254,6 +250,11 @@ public function validation_rules(array $rules = [])
         $this->validation_rules = $rules;
     }
 
+    public function set_fields_error_messages(array $fields_error_messages)
+    {
+        return $this->fields_error_messages = $fields_error_messages;
+    }
+
     /**
      * Getter/Setter for the filter rules.
      *
@@ -285,7 +286,7 @@ public function run(array $data, $check_fields = false)
         $data = $this->filter($data, $this->filter_rules());
 
         $validated = $this->validate(
-            $data, $this->validation_rules()
+            $data, $this->validation_rules(), $this->fields_error_messages
         );
 
         if ($check_fields === true) {
@@ -375,18 +376,17 @@ public function errors()
 
     /**
      * Perform data validation against the provided ruleset.
-     * If any rule's parameter contains either '|' or ',', the corresponding default separator can be changed
      *
      * @param mixed $input
      * @param array $ruleset
-     * @param array $custom_messages
+     * @param array $fields_error_messages
      * @return mixed
      * @throws Exception
      */
-    public function validate(array $input, array $ruleset, array $custom_messages = [])
+    public function validate(array $input, array $ruleset, array $fields_error_messages = [])
     {
         $this->errors = [];
-        $this->custom_messages = $custom_messages;
+        $this->fields_error_messages = $fields_error_messages;
 
         foreach ($ruleset as $field => $rawRules) {
             $input[$field] = $input[$field] ?? null;
@@ -400,7 +400,7 @@ public function validate(array $input, array $ruleset, array $custom_messages =
 
             foreach ($rules as $rule) {
                 $parsed_rule = $this->parse_rule($rule);
-                $result = $this->call_rule($parsed_rule['rule'], $field, $input, $parsed_rule['param']);
+                $result = $this->call_validator($parsed_rule['rule'], $field, $input, $parsed_rule['param']);
 
                 if (is_array($result)) {
                     $this->errors[] = $result;
@@ -509,6 +509,8 @@ private static function validator_to_method(string $rule)
     }
 
     /**
+     * Calls a validator.
+     *
      * @param string $rule
      * @param string $field
      * @param mixed $input
@@ -516,7 +518,7 @@ private static function validator_to_method(string $rule)
      * @return array|bool
      * @throws Exception
      */
-    private function call_rule(string $rule, string $field, $input, $rule_param = null)
+    private function call_validator(string $rule, string $field, $input, $rule_param = null)
     {
         $method = self::validator_to_method($rule);
 
@@ -571,10 +573,10 @@ public static function set_field_name(string $field, string $readable_name)
      *
      * Usage:
      *
-     * GUMP::set_field_names(array(
-     *  "name" => "My Lovely Name",
-     *  "username" => "My Beloved Username",
-     * ));
+     * GUMP::set_field_names([
+     *     'name' => 'My Lovely Name',
+     *     'username' => 'My Beloved Username'
+     * ]);
      *
      * @param array $array
      */
@@ -650,15 +652,15 @@ public function get_readable_errors(bool $convert_to_string = false, string $fie
         $messages = $this->get_messages();
         $result = [];
 
-        foreach ($this->errors as $e) {
-            if (!isset($messages[$e['rule']])) {
-                throw new Exception('Rule "'.$e['rule'].'" does not have an error message');
+        foreach ($this->errors as $error) {
+            if (!isset($messages[$error['rule']])) {
+                throw new Exception('Rule "'.$error['rule'].'" does not have an error message');
             }
 
+            $message = $this->get_custom_error_message($error['field'], $error['rule']) ?? $messages[$error['rule']];
             $result[] = $this->process_error_message(
-                $e['field'],  $e['param'],  $messages[$e['rule']],
-
-                function($replace) use($field_class) {
+                $error['field'],  $error['param'],  $message,
+                static function($replace) use($field_class) {
                     $replace['{field}'] = sprintf('<span class="%s">%s</span>', $field_class, $replace['{field}']);
                     return $replace;
                 }
@@ -677,31 +679,32 @@ function($replace) use($field_class) {
     /**
      * Process the validation errors and return an array of errors with field names as keys.
      *
-     * @param bool $convert_to_string
      * @return array
      * @throws Exception
      */
-    public function get_errors_array(bool $convert_to_string = false)
+    public function get_errors_array()
     {
-        if (empty($this->errors)) {
-            return ($convert_to_string) ? null : [];
-        }
-
         $messages = $this->get_messages();
         $result = [];
 
-        foreach ($this->errors as $e) {
-            if (!isset($messages[$e['rule']])) {
-                throw new Exception('Rule "'.$e['rule'].'" does not have an error message');
+        foreach ($this->errors as $error) {
+            if (!isset($messages[$error['rule']])) {
+                throw new Exception('Rule "'.$error['rule'].'" does not have an error message');
             }
 
-            $message = $this->custom_messages[$e['field']][str_replace('validate_', '', $e['rule'])] ?? $messages[$e['rule']];
-            $result[$e['field']] = $this->process_error_message($e['field'], $e['param'], $message);
+            $message = $this->get_custom_error_message($error['field'], $error['rule']) ?? $messages[$error['rule']];
+            $result[$error['field']] = $this->process_error_message($error['field'], $error['param'], $message);
         }
 
         return $result;
     }
 
+    private function get_custom_error_message(string $field, string $rule)
+    {
+        $rule_name = str_replace('validate_', '', $rule);
+        return $this->fields_error_messages[$field][$rule_name] ?? null;
+    }
+
     private function process_error_message($field, $param, string $message, callable $transformer = null)
     {
         // if field name is explicitly set, use it
@@ -729,7 +732,9 @@ private function process_error_message($field, $param, string $message, callable
         }
 
         // for get_readable_errors() <span>
-        if ($transformer) $replace = $transformer($replace);
+        if ($transformer) {
+            $replace = $transformer($replace);
+        }
 
         return strtr($message, $replace);
     }
@@ -739,9 +744,7 @@ private function process_error_message($field, $param, string $message, callable
      *
      * @param mixed  $input
      * @param array  $filterset
-     *
      * @return mixed
-     *
      * @throws Exception
      */
     public function filter(array $input, array $filterset)
@@ -776,7 +779,16 @@ private static function filter_to_method(string $rule)
         return sprintf('filter_%s', $rule);
     }
 
-    public function call_filter(string $filter, $value, $params)
+    /**
+     * Calls a filter.
+     *
+     * @param string $filter
+     * @param $value
+     * @param $params
+     * @return mixed
+     * @throws Exception
+     */
+    private function call_filter(string $filter, $value, $params)
     {
         $method = self::filter_to_method($filter);
 
diff --git a/tests/GetErrorsArrayTest.php b/tests/GetErrorsArrayTest.php
index 81bfe549..65daa7b0 100644
--- a/tests/GetErrorsArrayTest.php
+++ b/tests/GetErrorsArrayTest.php
@@ -23,17 +23,6 @@ public function testReturnsEmptyArrayWhenNoErrors()
         $this->assertEquals([], $this->gump->get_errors_array());
     }
 
-    public function testReturnsNullWhenNoErrorsAndConvertingToStringIsSet()
-    {
-        $result = $this->gump->validate([
-            'test_number' => '111'
-        ], [
-            'test_number' => 'numeric'
-        ]);
-
-        $this->assertNull($this->gump->get_errors_array(true));
-    }
-
     public function testReturnsErrorsWithFieldAsKey()
     {
         $result = $this->gump->validate([
@@ -138,15 +127,14 @@ public function testItThrowsExceptionWhenCustomValidatorFailsWithoutAnErrorMessa
         $this->gump->get_errors_array();
     }
 
-    public function testCustomErrorMessages()
+    public function testCustomFieldsErrorMessages()
     {
         $this->gump->validate([
             'test_number' => '123'
         ], [
-            'test_number' => 'required|between_len,1;2'
+            'test_number' => 'between_len,1;2'
         ], [
             'test_number' => [
-                'required' => 'Test Number can not be empty. Please fill it up.',
                 'between_len' => '{field} length MUST be between {param[0]} and {param[1]} !!!'
             ]
         ]);
diff --git a/tests/GetReadableErrorsTest.php b/tests/GetReadableErrorsTest.php
index e5476498..5e31ced5 100644
--- a/tests/GetReadableErrorsTest.php
+++ b/tests/GetReadableErrorsTest.php
@@ -133,4 +133,21 @@ public function testWhenGumpInstanceIsCastedToStringItReturnsReadableErrorsInStr
             (string)$this->gump
         );
     }
+
+    public function testCustomFieldsErrorMessages()
+    {
+        $this->gump->validate([
+            'test_number' => '123'
+        ], [
+            'test_number' => 'between_len,1;2'
+        ], [
+            'test_number' => [
+                'between_len' => '{field} length MUST be between {param[0]} and {param[1]} !!!'
+            ]
+        ]);
+
+        $this->assertEquals([
+            '<span class="gump-field">Test Number</span> length MUST be between 1 and 2 !!!'
+        ], $this->gump->get_readable_errors());
+    }
 }
\ No newline at end of file
diff --git a/tests/StaticIsValidTest.php b/tests/StaticIsValidTest.php
index 412ee050..894d3eec 100644
--- a/tests/StaticIsValidTest.php
+++ b/tests/StaticIsValidTest.php
@@ -29,10 +29,12 @@ public function testOnFailureReturnsArrayWithErrors()
             'test' => 'asd'
         ], [
             'test' => 'numeric'
+        ], [
+            'test' => ['numeric' => '{field} must be a number please !!!']
         ]);
 
         $this->assertEquals([
-            'The <span class="gump-field">Test</span> field must be a number'
+            '<span class="gump-field">Test</span> must be a number please !!!'
         ], $result);
     }
 }
\ No newline at end of file

From 6297d4b074a5ecf33d8876a70dfe700da079858a Mon Sep 17 00:00:00 2001
From: Filis Futsarov <filisko@users.noreply.github.com>
Date: Mon, 9 Mar 2020 21:33:03 +0100
Subject: [PATCH 5/9] Update README.md

---
 README.md | 26 ++++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 5601d933..f95fd9b8 100644
--- a/README.md
+++ b/README.md
@@ -19,21 +19,25 @@ composer require wixel/gump
 ```php
 $is_valid = GUMP::is_valid(array_merge($_POST, $_FILES), [
     'username' => 'required|alpha_numeric',
-    'password' => 'required|max_len,100|min_len,6',
+    'password' => 'required|between_len,4;100',
     'avatar'   => 'required_file|extension,png;jpg'
 ]);
 
 // recommended format (supported since v1.7)
 $is_valid = GUMP::is_valid(array_merge($_POST, $_FILES), [
     'username' => ['required', 'alpha_numeric'],
-    'password' => ['required', 'max_len' => 100, 'min_len' => 6],
+    'password' => ['required', 'between_len' => [6, 100]],
     'avatar'   => ['required_file', 'extension' => ['png', 'jpg']]
+], [ // field-rule specific error messages
+    'username' => ['required' => 'Fill the Username field please.'],
+    'password' => ['between_len' => '{field} must be between {param[0]} and {param[1]} characters please.'],
+    'avatar'   => ['extension' => 'Valid extensions for avatar are: {param}'] // "png, jpg"
 ]);
 
 if ($is_valid === true) {
     // continue
 } else {
-    print_r($is_valid);
+    var_dump($is_valid); // array of error messages
 }
 ```
 
@@ -65,6 +69,12 @@ $gump->validation_rules([
     'credit_card' => 'required|valid_cc'
 ]);
 
+// field-specific error messages
+$gump->set_fields_error_messages([
+    'username' => ['required' => 'Fill the Username field please, its required.'],
+    'credit_card'   => ['extension' => 'Please enter a valid credit card.']
+]);
+
 $gump->filter_rules([
     'username' => 'trim|sanitize_string',
     'password' => 'trim',
@@ -73,14 +83,14 @@ $gump->filter_rules([
     'bio'      => 'noise_words'
 ]);
 
-$validated_data = $gump->run($_POST);
+$valid_data = $gump->run($_POST);
 
-if ($validated_data === false) {
-    var_dump($gump->get_readable_errors()); // ['Field X is required.']
+if ($valid_data === false) {
+    var_dump($gump->get_readable_errors()); // For HTML: ['Field <span class="gump-field">Somefield</span> is required.'] 
     // or
-    var_dump($gump->get_errors_array()); // ['field' => 'Field X is required']
+    var_dump($gump->get_errors_array()); // For APIs?: ['field' => 'Field Somefield is required']
 } else {
-    var_dump($validated_data); // validation successful
+    var_dump($valid_data); // after filters result: ['field' => 'value']
 }
 ```
 

From b8ba204431c9a82bc1756c12902e8d479af3ef35 Mon Sep 17 00:00:00 2001
From: Filis Futsarov <filisko@users.noreply.github.com>
Date: Mon, 9 Mar 2020 21:34:16 +0100
Subject: [PATCH 6/9] Update README.md

---
 README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index f95fd9b8..ef518128 100644
--- a/README.md
+++ b/README.md
@@ -23,12 +23,12 @@ $is_valid = GUMP::is_valid(array_merge($_POST, $_FILES), [
     'avatar'   => 'required_file|extension,png;jpg'
 ]);
 
-// recommended format (supported since v1.7)
+// recommended format (supported since v1.7) with field-rule specific error messages example
 $is_valid = GUMP::is_valid(array_merge($_POST, $_FILES), [
     'username' => ['required', 'alpha_numeric'],
     'password' => ['required', 'between_len' => [6, 100]],
     'avatar'   => ['required_file', 'extension' => ['png', 'jpg']]
-], [ // field-rule specific error messages
+], [
     'username' => ['required' => 'Fill the Username field please.'],
     'password' => ['between_len' => '{field} must be between {param[0]} and {param[1]} characters please.'],
     'avatar'   => ['extension' => 'Valid extensions for avatar are: {param}'] // "png, jpg"
@@ -45,10 +45,10 @@ if ($is_valid === true) {
 
 ```php
 $filtered = GUMP::filter_input([
-    'field' => ' text ',
+    'field'       => ' text ',
     'other_field' => 'Cool Title'
 ], [
-    'field' => ['trim', 'upper_case'],
+    'field'       => ['trim', 'upper_case'],
     'other_field' => 'slug'
 ]);
 
@@ -71,7 +71,7 @@ $gump->validation_rules([
 
 // field-specific error messages
 $gump->set_fields_error_messages([
-    'username' => ['required' => 'Fill the Username field please, its required.'],
+    'username'      => ['required' => 'Fill the Username field please, its required.'],
     'credit_card'   => ['extension' => 'Please enter a valid credit card.']
 ]);
 

From 5757e6920095a60c627360580bcafbb6d1b8ab76 Mon Sep 17 00:00:00 2001
From: Filis Futsarov <filisko@users.noreply.github.com>
Date: Mon, 9 Mar 2020 21:34:38 +0100
Subject: [PATCH 7/9] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ef518128..7b85ede3 100644
--- a/README.md
+++ b/README.md
@@ -30,7 +30,7 @@ $is_valid = GUMP::is_valid(array_merge($_POST, $_FILES), [
     'avatar'   => ['required_file', 'extension' => ['png', 'jpg']]
 ], [
     'username' => ['required' => 'Fill the Username field please.'],
-    'password' => ['between_len' => '{field} must be between {param[0]} and {param[1]} characters please.'],
+    'password' => ['between_len' => '{field} must be between {param[0]} and {param[1]} characters.'],
     'avatar'   => ['extension' => 'Valid extensions for avatar are: {param}'] // "png, jpg"
 ]);
 

From be7275f4dbb6d6b303f27b51ead15756f63d100a Mon Sep 17 00:00:00 2001
From: Filis Futsarov <filisfutsarov@gmail.com>
Date: Mon, 9 Mar 2020 21:37:06 +0100
Subject: [PATCH 8/9] code cleanup

---
 gump.class.php | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/gump.class.php b/gump.class.php
index cd0e44e3..b01d08ae 100644
--- a/gump.class.php
+++ b/gump.class.php
@@ -52,6 +52,9 @@ public static function get_instance()
 
     public static $rules_parameters_arrays_delimiter = ';';
 
+    // field characters below will be replaced with a space.
+    public static $field_chars_to_spaces = ['_', '-'];
+
     // ** ------------------------- Validation Data ------------------------------- ** //
 
     public static $basic_tags = '<br><p><a><strong><b><i><em><img><blockquote><code><dd><dl><hr><h1><h2><h3><h4><h5><h6><label><ul><li><span><sub><sup>';
@@ -68,9 +71,6 @@ public static function get_instance()
     public static $trues = ['1', 1, 'true', true, 'yes', 'on'];
     public static $falses = ['0', 0, 'false', false, 'no', 'off'];
 
-    // field characters below will be replaced with a space.
-    protected $fieldCharsToRemove = array('_', '-');
-
     protected $lang;
 
     protected $fields_error_messages = [];
@@ -84,7 +84,6 @@ public static function get_instance()
     // Instance attribute containing errors from last run
     protected $errors = [];
 
-
     // ** ------------------------- Validation Helpers ---------------------------- ** //
 
     public function __construct(string $lang = 'en')
@@ -711,7 +710,7 @@ private function process_error_message($field, $param, string $message, callable
         if (array_key_exists($field, self::$fields)) {
             $field = self::$fields[$field];
         } else {
-            $field = ucwords(str_replace($this->fieldCharsToRemove, chr(32), $field));
+            $field = ucwords(str_replace(self::$field_chars_to_spaces, chr(32), $field));
         }
 
         // if param is a field (i.e. equalsfield validator)

From bd6917fa8646f137b604e8c14e5ee3081cc4de00 Mon Sep 17 00:00:00 2001
From: Filis Futsarov <filisko@users.noreply.github.com>
Date: Mon, 9 Mar 2020 21:43:32 +0100
Subject: [PATCH 9/9] Update README.md

---
 README.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/README.md b/README.md
index 7b85ede3..31def9e8 100644
--- a/README.md
+++ b/README.md
@@ -342,3 +342,16 @@ if ($validated === true) {
     print_r($validated);
 }
 ```
+
+
+Global configuration
+--------------------
+This configuration values would allow you to turn: `required|contains,value1;value2` into `required|contains:value1,value2`.
+
+```php
+GUMP::$rules_delimiter = '|';
+
+GUMP::$rules_parameters_delimiter = ',';
+
+GUMP::$rules_parameters_arrays_delimiter = ';';
+```