Merge pull request #365 from blueyestar/master

added missing translation for zh-cn and zh-tw
Merge pull request #364 from metakin/fix-typo
2025-12-30 23:01:52 +00:00 · 2022-10-14 13:54:24 +02:00 · 2022-10-14 13:53:54 +02:00 · 2022-10-14 13:52:39 +02:00 · 2022-10-14 13:52:03 +02:00 · 2022-10-11 11:56:38 -04:00
45 changed files with 1329 additions and 259 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@ -0,0 +1 @@
+tidelift: "packagist/vlucas/valitron"
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@ -0,0 +1,73 @@
+name: Run Tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.operating-system }}
+    strategy:
+      matrix:
+        operating-system: ['ubuntu-latest']
+        php-versions:
+        - '5.4'
+        - '5.5'
+        - '5.6'
+        - '7.0'
+        - '7.1'
+        - '7.2'
+        - '7.3'
+        - '7.4'
+        - '8.0'
+ #      - '8.1'
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php-versions }}
+      - name: Cache composer packages
+        id: composer-cache
+        uses: actions/cache@v2
+        with:
+          path: vendor
+          key: ${{ runner.os }}-php-${{ matrix.php-versions }}-${{ hashFiles('**/composer.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-php-${{ matrix.php-versions }}-
+      - name: Validate composer configuration
+        run: |
+          composer validate
+      - name: Install dependencies
+        run: |
+          composer install --no-progress
+      - name: Run tests
+        run: |
+          composer run-script test
+
+#  test-hhvm:
+#    runs-on: ubuntu-latest
+#    steps:
+#      - name: Checkout
+#        uses: actions/checkout@v2
+#      - name: Setup HHVM
+#        uses: azjezz/setup-hhvm@v1
+#        with:
+#          version: latest
+#          debug: false
+#      - name: Cache composer packages
+#        id: composer-cache
+#        uses: actions/cache@v2
+#        with:
+#          path: vendor
+#          key: ${{ runner.os }}-hhvm-${{ hashFiles('**/composer.lock') }}
+#          restore-keys: |
+#            ${{ runner.os }}-hhvm-
+#      - name: Validate composer configuration
+#        run: |
+#          composer validate
+#      - name: Install dependencies
+#        run: |
+#          composer install --no-progress
+#      - name: Run tests
+#        run: |
+#          composer run-script test
--- a/.gitignore
+++ b/.gitignore
@ -3,3 +3,4 @@ composer.phar
 composer.lock
 vendor
 .idea/
+.phpunit.result.cache
--- a/.travis.yml
+++ b/.travis.yml
@ -1,27 +0,0 @@
-# see http://about.travis-ci.org/docs/user/languages/php/ for more hints
-language: php
-
-# list any PHP version you want to test against
-php:
-  - 5.4
-  - 5.5
-  - 5.6
-  - 7.0
-  - 7.1
-  - 7.2
-  - nightly
-  - hhvm
-
-matrix:
-  allow_failures:
-    - php: hhvm
-    - php: nightly
-  include:
-    - php: 5.3
-      dist: precise
-
-before_script:
-  - composer install
-
-# Script to run tests
-script: composer test
--- a/README.md
+++ b/README.md
@ -6,10 +6,12 @@ methods with a focus on readable and concise syntax. Valitron is the
 simple and pragmatic validation library you've been looking for.

 [![Build
-Status](https://travis-ci.org/vlucas/valitron.png?branch=master)](https://travis-ci.org/vlucas/valitron)
+Status](https://github.com/vlucas/valitron/actions/workflows/test.yml/badge.svg)](https://github.com/vlucas/valitron/actions/workflows/test.yml)
 [![Latest Stable Version](https://poser.pugx.org/vlucas/valitron/v/stable.png)](https://packagist.org/packages/vlucas/valitron)
 [![Total Downloads](https://poser.pugx.org/vlucas/valitron/downloads.png)](https://packagist.org/packages/vlucas/valitron)

+[Get supported vlucas/valitron with the Tidelift Subscription](https://tidelift.com/subscription/pkg/packagist-vlucas-valitron?utm_source=packagist-vlucas-valitron&utm_medium=referral&utm_campaign=readme) 
+
 ## Why Valitron?

 Valitron was created out of frustration with other validation libraries
@ -125,11 +127,63 @@ V::lang('ar');

 ```

+Disabling the {field} name in the output of the error message. 

+```php
+use Valitron\Validator as V;
+
+$v = new Valitron\Validator(['name' => 'John']);
+$v->rule('required', ['name']);
+
+// Disable prepending the labels
+$v->setPrependLabels(false);
+
+// Error output for the "false" condition
+[
+    ["name"] => [
+        "is required"
+    ]
+]
+
+// Error output for the default (true) condition
+[
+    ["name"] => [
+        "name is required"
+    ]
+]
+
+```
+
+You can conditionally require values using required conditional rules. In this example, for authentication, we're requiring either a token when both the email and password are not present, or a password when the email address is present.
+```php
+// this rule set would work for either data set...
+$data = ['email' => 'test@test.com', 'password' => 'mypassword'];
+// or...
+$data = ['token' => 'jashdjahs83rufh89y38h38h'];
+
+$v = new Valitron\Validator($data);
+$v->rules([
+    'requiredWithout' => [
+        ['token', ['email', 'password'], true]
+    ],
+    'requiredWith' => [
+        ['password', ['email']]
+    ],
+    'email' => [
+        ['email']
+    ]
+    'optional' => [
+        ['email']
+    ]
+]);
+$this->assertTrue($v->validate());
+```

 ## Built-in Validation Rules

 * `required` - Field is required
+ * `requiredWith` - Field is required if any other fields are present
+ * `requiredWithout` - Field is required if any other fields are NOT present
 * `equals` - Field must match another field (email/password confirmation)
 * `different` - Field must be different than another field
 * `accepted` - Checkbox or Radio must be accepted (yes, on, 1, true)
@ -143,6 +197,7 @@ V::lang('ar');
 * `lengthMax` - String must be less than given length
 * `min` - Minimum
 * `max` - Maximum
+ * `listContains` - Performs in_array check on given array values (the other way round than `in`)
 * `in` - Performs in_array check on given array values
 * `notIn` - Negation of `in` rule (not in array of values)
 * `ip` - Valid IP address
@ -167,6 +222,7 @@ V::lang('ar');
 * `creditCard` - Field is a valid credit card number
 * `instanceOf` - Field contains an instance of the given class
 * `optional` - Value does not need to be included in data array. If it is however, it must pass validation.
+ * `arrayHasKeys` - Field is an array and contains all specified keys.

 **NOTE**: If you are comparing floating-point numbers with min/max validators, you
 should install the [BCMath](http://us3.php.net/manual/en/book.bc.php)
@ -198,7 +254,133 @@ $v->rules([
 $v->validate();
 ```

-Example using alternate syntax.
+## requiredWith fields usage
+The `requiredWith` rule checks that the field is required, not null, and not the empty string, if any other fields are present, not null, and not the empty string.
+```php
+// password field will be required when the username field is provided and not empty
+$v->rule('requiredWith', 'password', 'username');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'spiderman', 'password' => 'Gr33nG0Blin']);
+$v->rules([
+    'requiredWith' => [
+        ['password', 'username']
+    ]
+]);
+$v->validate();
+```
+
+*Note* You can provide multiple values as an array. In this case if ANY of the fields are present the field will be required.
+```php
+// in this case the password field will be required if the username or email fields are present
+$v->rule('requiredWith', 'password', ['username', 'email']);
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'spiderman', 'password' => 'Gr33nG0Blin']);
+$v->rules([
+    'requiredWith' => [
+        ['password', ['username', 'email']]
+    ]
+]);
+$v->validate();
+```
+
+### Strict flag
+The strict flag will change the `requiredWith` rule to `requiredWithAll` which will require the field only if ALL of the other fields are present, not null, and not the empty string.
+```php
+// in this example the suffix field is required only when both the first_name and last_name are provided
+$v->rule('requiredWith', 'suffix', ['first_name', 'last_name'], true);
+```
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['first_name' => 'steve', 'last_name' => 'holt', 'suffix' => 'Mr']);
+$v->rules([
+    'requiredWith' => [
+        ['suffix', ['first_name', 'last_name'], true]
+    ]
+]);
+$v->validate();
+```
+
+Likewise, in this case `validate()` would still return true, as the suffix field would not be required in strict mode, as not all of the fields are provided.
+```php
+$v = new Valitron\Validator(['first_name' => 'steve']);
+$v->rules([
+    'requiredWith' => [
+        ['suffix', ['first_name', 'last_name'], true]
+    ]
+]);
+$v->validate();
+```
+
+## requiredWithout fields usage
+The `requiredWithout` rule checks that the field is required, not null, and not the empty string, if any other fields are NOT present.
+```php
+// this rule will require the username field when the first_name is not present
+$v->rule('requiredWithout', 'username', 'first_name')
+```
+
+Alternate syntax.
+```php
+// this will return true, as the username is provided when the first_name is not provided
+$v = new Valitron\Validator(['username' => 'spiderman']);
+$v->rules([
+    'requiredWithout' => [
+        ['username', 'first_name']
+    ]
+]);
+$v->validate();
+```
+
+*Note* You can provide multiple values as an array. In this case if ANY of the fields are NOT present the field will be required.
+```php
+// in this case the username field will be required if either the first_name or last_name fields are not present
+$v->rule('requiredWithout', 'username', ['first_name', 'last_name']);
+```
+
+Alternate syntax.
+```php
+// this passes validation because although the last_name field is not present, the username is provided
+$v = new Valitron\Validator(['username' => 'spiderman', 'first_name' => 'Peter']);
+$v->rules([
+    'requiredWithout' => [
+        ['username', ['first_name', 'last_name']]
+    ]
+]);
+$v->validate();
+```
+
+### Strict flag
+The strict flag will change the `requiredWithout` rule to `requiredWithoutAll` which will require the field only if ALL of the other fields are not present.
+```php
+// in this example the username field is required only when both the first_name and last_name are not provided
+$v->rule('requiredWithout', 'username', ['first_name', 'last_name'], true);
+```
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'BatMan']);
+$v->rules([
+    'requiredWithout' => [
+        ['username', ['first_name', 'last_name'], true]
+    ]
+]);
+$v->validate();
+```
+
+Likewise, in this case `validate()` would still return true, as the username field would not be required in strict mode, as all of the fields are provided.
+```php
+$v = new Valitron\Validator(['first_name' => 'steve', 'last_name' => 'holt']);
+$v->rules([
+    'requiredWithout' => [
+        ['suffix', ['first_name', 'last_name'], true]
+    ]
+]);
+$v->validate();
+```

 ## equals fields usage
 The `equals` rule checks if two fields are equals in the data array, and that the second field is not null.
@ -285,24 +467,19 @@ $v->rules([
 $v->validate();
 ```

-*Note* the optional boolean flag for strict mode will allow for integers to be supplied as negative values. So the following rule would evaluate to true:
+*Note* the optional boolean flag for strict mode makes sure integers are to be supplied in a strictly numeric form. So the following rule would evaluate to true:
 ```php
-$v = new Valitron\Validator(['age' => '-27']);
-$v->rules([
-    'integer' => [
-        ['age', true]
-    ]
-]);
+$v = new Valitron\Validator(['negative' => '-27', 'positive'=>'27']);
+$v->rule('integer', 'age', true);
+$v->rule('integer', 'height', true);
 $v->validate();
 ```
-Whereas the same for a positive (+) value would evaluate to false, as the + in this case is redundant:
+
+Whereas the following will evaluate to false, as the + for the positive number in this case is redundant:
 ```php
-$v = new Valitron\Validator(['age' => '+27']);
-$v->rules([
-    'integer' => [
-        ['age', true]
-    ]
-]);
+$v = new Valitron\Validator(['negative' => '-27', 'positive'=>'+27']);
+$v->rule('integer', 'age', true);
+$v->rule('integer', 'height', true);
 $v->validate();
 ```

@ -442,6 +619,23 @@ $v->rules([
 $v->validate();
 ```

+## listContains fields usage
+The `listContains` rule checks that the field is present in a given array of values.
+```php
+$v->rule('listContains', 'color', 'yellow');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['color' => ['blue', 'green', 'red', 'yellow']]);
+$v->rules([
+    'listContains' => [
+        ['color', 'yellow']
+    ]
+]);
+$v->validate();
+```
+
 ## in fields usage
 The `in` rule checks that the field is present in a given array of values.
 ```php
@ -938,6 +1132,23 @@ $v->rules([
 $v->validate();
 ```

+## arrayHasKeys fields usage
+
+The `arrayHasKeys` rule ensures that the field is an array and that it contains all the specified keys.
+Returns false if the field is not an array or if no required keys are specified or if some key is missing.
+
+```php
+$v = new Valitron\Validator([
+    'address' => [
+        'name' => 'Jane Doe',
+        'street' => 'Doe Square',
+        'city' => 'Doe D.C.'
+    ]
+]);
+$v->rule('arrayHasKeys', 'address', ['name', 'street', 'city']);
+$v->validate();
+```
+
 ## Adding Custom Validation Rules

 To add your own validation rule, use the `addRule` method with a rule
@ -952,7 +1163,7 @@ Valitron\Validator::addRule('alwaysFail', function($field, $value, array $params
 ```

 You can also use one-off rules that are only valid for the specified
-fields. 
+fields.

 ```php
 $v = new Valitron\Validator(array("foo" => "bar"));
@ -964,12 +1175,12 @@ $v->rule(function($field, $value, $params, $fields) {
 This is useful because such rules can have access to variables
 defined in the scope where the `Validator` lives. The Closure's
 signature is identical to `Validator::addRule` callback's
-signature. 
+signature.

 If you wish to add your own rules that are not static (i.e.,
-your rule is not static and available to call `Validator` 
-instances), you need to use `Validator::addInstanceRule`. 
-This rule will take the same parameters as 
+your rule is not static and available to call `Validator`
+instances), you need to use `Validator::addInstanceRule`.
+This rule will take the same parameters as
 `Validator::addRule` but it has to be called on a `Validator`
 instance.

@ -1049,7 +1260,7 @@ You can also add rules on a per-field basis:
 $rules = [
    'required',
    ['lengthMin', 4]
-];   
+];

 $v = new Valitron\Validator(array('foo' => 'bar'));
 $v->mapFieldRules('foo', $rules);
@ -1138,3 +1349,6 @@ before running the tests:
 7. Create new Pull Request
 8. Pat yourself on the back for being so awesome

+## Security Disclosures and Contact Information
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.
--- a/composer.json
+++ b/composer.json
@ -3,20 +3,20 @@
    "type": "library",
    "description": "Simple, elegant, stand-alone validation library with NO dependencies",
    "keywords": ["validation", "validator", "valid"],
-    "homepage": "http://github.com/vlucas/valitron",
+    "homepage": "https://github.com/vlucas/valitron",
    "license": "BSD-3-Clause",
    "authors": [
        {
            "name": "Vance Lucas",
            "email": "vance@vancelucas.com",
-            "homepage": "http://www.vancelucas.com"
+            "homepage": "https://www.vancelucas.com"
        }
    ],
    "require": {
        "php": ">=5.3.2"
    },
    "require-dev": {
-        "phpunit/phpunit": "^4.8.35 || ^5.5 || ^6.5"
+        "phpunit/phpunit": ">=4.8.35"
    },
    "suggest": {
        "ext-mbstring": "It can support the multiple bytes string length."
--- a/lang/ar.php
+++ b/lang/ar.php
@ -11,6 +11,7 @@ return array(
    'min'           => "يجب ان يكون اعلي من  %s",
    'max'           => "يجب ان يكون اقل من %s",
    'in'            => "الُمدخل يغير صحيح",
+    'listContains'  => "الُمدخل يغير صحيح",
    'notIn'         => "الُمدخل يغير صحيح",
    'ip'            => "رقم الإتصال غير صحيح",
    'email'         => "البريد الألكتروني غير صحيح",
--- a/lang/az.php
+++ b/lang/az.php
@ -10,6 +10,7 @@ return array(
    'length'        => "%d qədər uzunluğu olmalıdır",
    'min'           => "minimum %s qədər olmalıdır",
    'max'           => "maksimum %s qədər olmalıdır",
+    'listContains'  => "yalnış dəyər ehtiva edir",
    'in'            => "yalnış dəyər ehtiva edir",
    'notIn'         => "yalnış dəyər ehtiva edir",
    'ip'            => "düzgün IP ünvanı deyil",
--- a/lang/bg.php
+++ b/lang/bg.php
@ -10,6 +10,7 @@ return array(
    'length'        => "трябва да бъде %d символа дълго",
    'min'           => "трябвя да бъде поне %s",
    'max'           => "трябва да бъде не повече от %s",
+    'listContains'  => "съдържа невалидна стойност",
    'in'            => "съдържа невалидна стойност",
    'notIn'         => "съдържа невалидна стойност",
    'ip'            => "е невалиден IP адрес",
--- a/lang/de.php
+++ b/lang/de.php
@ -10,6 +10,7 @@ return array(
    'length'        => "kann nicht länger als %d sein",
    'min'           => "muss größer als %s sein",
    'max'           => "muss kleiner als %s sein",
+    'listContains'  => "enthält einen ungültigen Wert",
    'in'            => "enthält einen ungültigen Wert",
    'notIn'         => "enthält einen ungültigen Wert",
    'ip'            => "enthält keine gültige IP-Addresse",
--- a/lang/el.php
+++ b/lang/el.php
@ -10,6 +10,7 @@ return array(
    'length'        => "πρέπει να είναι μεγαλύτερο από %d",
    'min'           => "πρέπει να είναι τουλάχιστον %s",
    'max'           => "δεν πρέπει να είναι περισσότερο από %s",
+    'listContains'  => "περιέχει μη έγκυρη τιμή",
    'in'            => "περιέχει μη έγκυρη τιμή",
    'notIn'         => "περιέχει μη έγκυρη τιμή",
    'ip'            => "δεν είναι έγκυρη διεύθυνση IP",
--- a/lang/en.php
+++ b/lang/en.php
@ -10,6 +10,7 @@ return array(
    'length'         => "must be %d characters long",
    'min'            => "must be at least %s",
    'max'            => "must be no more than %s",
+    'listContains'   => "contains invalid value",
    'in'             => "contains invalid value",
    'notIn'          => "contains invalid value",
    'ip'             => "is not a valid IP address",
@ -34,5 +35,8 @@ return array(
    'lengthMax'      => "must not exceed %d characters",
    'instanceOf'     => "must be an instance of '%s'",
    'containsUnique' => "must contain unique elements only",
+    'requiredWith'   => "is required",
+    'requiredWithout'=> "is required",
    'subset'         => "contains an item that is not in the list",
+    'arrayHasKeys'   => "does not contain all required keys",
 );
--- a/lang/es.php
+++ b/lang/es.php
@ -1,34 +1,37 @@
 <?php

 return array(
-    'required'      => "es obligatorio",
-    'equals'        => "debe ser igual a '%s'",
-    'different'     => "debe ser diferente a '%s'",
-    'accepted'      => "debe ser aceptado",
-    'numeric'       => "debe ser numérico",
-    'integer'       => "debe ser un entero",
-    'length'        => "debe ser mas largo de %d",
-    'min'           => "debe ser mayor de %s",
-    'max'           => "debe ser menor de %s",
-    'in'            => "contiene un valor inválido",
-    'notIn'         => "contiene un valor inválido",
-    'ip'            => "no es una dirección IP",
-    'email'         => "no es un correo electrónico válido",
-    'url'           => "no es una URL",
-    'urlActive'     => "debe ser un dominio activo",
-    'alpha'         => "debe contener solo letras a-z",
-    'alphaNum'      => "debe contener solo letras a-z o números 0-9",
-    'slug'          => "debe contener solo letras a-z, números 0-9, barras y guiones bajos",
-    'regex'         => "contiene caracteres inválidos",
-    'date'          => "no es una fecha válida",
-    'dateFormat'    => "debe ser una fecha con formato '%s'",
-    'dateBefore'    => "debe ser una fecha antes de '%s'",
-    'dateAfter'     => "debe ser una fecha después de '%s'",
-    'contains'      => "debe contener %s",
-    'boolean'       => "debe ser booleano",
-    'lengthBetween' => "debe tener entre %d y %d caracteres",
-    'creditCard'    => "debe ser un numero de tarjeta de crédito válido",
-    "lengthMin"     => "debe tener al menos %d caracteres",
-    "lengthMax"     => "debe tener menos de %d caracteres",
-    "instanceOf"    => "debe ser una instancia de '%s'"
+    'required'       => "es obligatorio",
+    'equals'         => "debe ser igual a '%s'",
+    'different'      => "debe ser diferente a '%s'",
+    'accepted'       => "debe ser aceptado",
+    'numeric'        => "debe ser numérico",
+    'integer'        => "debe ser un entero",
+    'length'         => "debe ser mas largo de %d",
+    'min'            => "debe ser mayor de %s",
+    'max'            => "debe ser menor de %s",
+    'in'             => "contiene un valor inválido",
+    'notIn'          => "contiene un valor inválido",
+    'ip'             => "no es una dirección IP",
+    'email'          => "no es un correo electrónico válido",
+    'url'            => "no es una URL",
+    'urlActive'      => "debe ser un dominio activo",
+    'alpha'          => "debe contener solo letras a-z",
+    'alphaNum'       => "debe contener solo letras a-z o números 0-9",
+    'slug'           => "debe contener solo letras a-z, números 0-9, barras y guiones bajos",
+    'regex'          => "contiene caracteres inválidos",
+    'date'           => "no es una fecha válida",
+    'dateFormat'     => "debe ser una fecha con formato '%s'",
+    'dateBefore'     => "debe ser una fecha antes de '%s'",
+    'dateAfter'      => "debe ser una fecha después de '%s'",
+    'contains'       => "debe contener %s",
+    'boolean'        => "debe ser booleano",
+    'lengthBetween'  => "debe tener entre %d y %d caracteres",
+    'creditCard'     => "debe ser un numero de tarjeta de crédito válido",
+    "lengthMin"      => "debe tener al menos %d caracteres",
+    "lengthMax"      => "debe tener menos de %d caracteres",
+    "instanceOf"     => "debe ser una instancia de '%s'",
+    'containsUnique' => "debe contener solo valores únicos",
+    'subset'         => "contiene un elemento que no está en la lista",
+    'arrayHasKeys'   => "no contiene todas las claves requeridas"    
 );
--- a/lang/fa.php
+++ b/lang/fa.php
@ -0,0 +1,42 @@
+<?php
+
+return array(
+    'required'       => "الزامی است",
+    'equals'         => " باید برابر باشد با '%s'",
+    'different'      => "باید متفاوت باشد از '%s'",
+    'accepted'       => "باید پذیرفته شده باشد",
+    'numeric'        => "باید مقدار عددی باشد",
+    'integer'        => "باید عددی طبیعی باشد",
+    'length'         => "طول باید %d باشد",
+    'min'            => "حداقل باید %s کاراکتر باشد",
+    'max'            => "نباید بیشتر از %s کارکتر باشد",
+    'listContains'   => "حاوی مقدار نامعتبر",
+    'in'             => "حاوی مقدار نامعتبر",
+    'notIn'          => "حاوی مقدار نامعتبر",
+    'ip'             => " آدرس معتبر نیست IP",
+    'ipv4'           => "آدرس معتبر نیست IPv4",
+    'ipv6'           => "آدرس معتبر نیست IPv6",
+    'email'          => "آدرس ایمیل معتبر نیست",
+    'url'            => "معتبر نیست URL",
+    'urlActive'      => "دامنه باید فعال باشد",
+    'alpha'          => "باید حاوی حروف a-z باشد",
+    'alphaNum'       => "باید حاوی حروف a-z و/یا اعداد 0-9 باشد",
+    'slug'           => "باید حاوی حروف a-z, اعداد 0-9, دش و آندراسکور باشد",
+    'regex'          => "حاوی کارکترهای نامعتبر",
+    'date'           => "تاریخ معتبر نیست",
+    'dateFormat'     => "فرمت تاریخ باید به این شکل '%s' باشد",
+    'dateBefore'     => "تاریخ باید قبل از '%s' باشد",
+    'dateAfter'      => "تاریخ باید بعد از '%s' باشد",
+    'contains'       => "باید حاوی %s باشد",
+    'boolean'        => "مقدار باید بولین باشد",
+    'lengthBetween'  => "طول باید بین %d و %d کاراکتر باشد",
+    'creditCard'     => "شماره کارت اعتباری معتبر نیست",
+    'lengthMin'      => "طول باید حداقل %d کاراکتر باشد",
+    'lengthMax'      => "طول نباید بیشتر از %d کاراکتر باشد",
+    'instanceOf'     => "باید آبجکتی از نوع '%s' باشد",
+    'containsUnique' => "باید حاوی المان ها یونیک باشد",
+    'requiredWith'   => "الزامی است",
+    'requiredWithout'=> "الزامی است",
+    'subset'         => "حاوی آیتمی است که در لیست موجود نیست",
+    'arrayHasKeys'   => "همه کلیدهای الزامی را ندارد",
+);
--- a/lang/fi.php
+++ b/lang/fi.php
@ -10,6 +10,7 @@ return array(
    'length'        => "on lyhyempi kuin %d",
    'min'           => "ei ole vähintään %s",
    'max'           => "ei ole enintään %s",
+    'listContains'  => "sisältää virheellisen arvon",
    'in'            => "sisältää virheellisen arvon",
    'notIn'         => "sisältää virheellisen arvon",
    'ip'            => "ei ole oikeanmuotoinen IP-osoite",
--- a/lang/fr.php
+++ b/lang/fr.php
@ -1,34 +1,40 @@
 <?php

-return array(
-    'required'      => "est obligatoire",
-    'equals'        => "doit être identique à '%s'",
-    'different'     => "doit être différent de '%s'",
-    'accepted'      => "doit être accepté",
-    'numeric'       => "doit être numérique",
-    'integer'       => "doit être un entier",
-    'length'        => "doit être plus long que %d",
-    'min'           => "doit être plus grand que %s",
-    'max'           => "doit être plus petit que %s",
-    'in'            => "contient une valeur non valide",
-    'notIn'         => "contient une valeur non valide",
-    'ip'            => "n'est pas une adresse IP valide",
-    'email'         => "n'est pas une adresse email valide",
-    'url'           => "n'est pas une URL",
-    'urlActive'     => "doit être un domaine actif",
-    'alpha'         => "doit contenir uniquement les lettres a-z",
-    'alphaNum'      => "doit contenir uniquement des lettres de a-z et/ou des chiffres 0-9",
-    'slug'          => "doit contenir uniquement des lettres de a-z, des chiffres 0-9, des tirets et des traits soulignés",
-    'regex'         => "contient des caractères invalides",
-    'date'          => "n'est pas une date valide",
-    'dateFormat'    => "doit être une date avec le format '%s'",
-    'dateBefore'    => "doit être une date avant '%s'",
-    'dateAfter'     => "doit être une date après '%s'",
-    'contains'      => "doit contenir %s",
-    'boolean'       => "doit être un booléen",
-    'lengthBetween' => "doit être entre %d et %d caractères",
-    'creditCard'    => "doit être un numéro de carte de crédit valide",
-    'lengthMin'     => "doit avoir au moins %d caractères",
-    'lengthMax'     => "ne doit pas dépasser %d caractères",
-    'instanceOf'    => "doit être une instance de '%s'"
+return array(   
+    'required'          => "est obligatoire",
+    'equals'            => "doit être identique à '%s'",
+    'different'         => "doit être différent de '%s'",
+    'accepted'          => "doit être accepté",
+    'numeric'           => "doit être numérique",
+    'integer'           => "doit être un entier",
+    'length'            => "doit être plus long que %d",
+    'min'               => "doit être plus grand que %s",
+    'max'               => "doit être plus petit que %s",
+    'listContains'      => "contient une valeur non valide",
+    'in'                => "contient une valeur non valide",
+    'notIn'             => "contient une valeur non valide",
+    'ip'                => "n'est pas une adresse IP valide",
+    'email'             => "n'est pas une adresse email valide",
+    'url'               => "n'est pas une URL",
+    'urlActive'         => "doit être un domaine actif",
+    'alpha'             => "doit contenir uniquement les lettres a-z",
+    'alphaNum'          => "doit contenir uniquement des lettres de a-z et/ou des chiffres 0-9",
+    'slug'              => "doit contenir uniquement des lettres de a-z, des chiffres 0-9, des tirets et des traits soulignés",
+    'regex'             => "contient des caractères invalides",
+    'date'              => "n'est pas une date valide",
+    'dateFormat'        => "doit être une date avec le format '%s'",
+    'dateBefore'        => "doit être une date avant '%s'",
+    'dateAfter'         => "doit être une date après '%s'",
+    'contains'          => "doit contenir %s",
+    'boolean'           => "doit être un booléen",
+    'lengthBetween'     => "doit être entre %d et %d caractères",
+    'creditCard'        => "doit être un numéro de carte de crédit valide",
+    'lengthMin'         => "doit avoir au moins %d caractères",
+    'lengthMax'         => "ne doit pas dépasser %d caractères",
+    'instanceOf'        => "doit être une instance de '%s'",
+    "containsUnique"    => "doit contenir des élements unique",
+    "requiredWith"      => "est requis",
+    "requiredWithout"   => "est requis",
+    "subset"            => "contient un élement qui n'est pas dans la liste",
+    "arrayHasKeys"      => "ne contient pas toutes les clés requises"
 );
--- a/lang/id.php
+++ b/lang/id.php
@ -10,6 +10,7 @@ return array(
    'length'        => "harus lebih panjang dari %d",
    'min'           => "harus lebih besar dari %s",
    'max'           => "harus kurang dari %s",
+    'listContains'  => "berisi nilai/value yang tidak valid",
    'in'            => "berisi nilai/value yang tidak valid",
    'notIn'         => "berisi nilai/value yang tidak valid",
    'ip'            => "format alamat IP tidak benar",
--- a/lang/it.php
+++ b/lang/it.php
@ -10,6 +10,7 @@ return array(
    'length'        => "deve avere una lunghezza di %d",
    'min'           => "deve essere superiore a %s",
    'max'           => "deve essere inferiore a %s",
+    'listContains'  => "contiene un valore non valido",
    'in'            => "contiene un valore non valido",
    'notIn'         => "contiene un valore non valido",
    'ip'            => "non è un indirizzo IP valido",
--- a/lang/ja.php
+++ b/lang/ja.php
@ -1,34 +1,42 @@
 <?php

 return array(
-    'required'      => "を入力してください",
-    'equals'        => "は「%s」と同じ内容を入力してください",
-    'different'     => "は「%s」と異なる内容を入力してください",
-    'accepted'      => "に同意してください",
-    'numeric'       => "は数値を入力してください",
-    'integer'       => "は半角数字で入力してください",
-    'length'        => "は%d文字で入力してください",
-    'min'           => "には%sより大きな値を入力してください",
-    'max'           => "には%sより小さな値を入力してください",
-    'in'            => "には選択できない値が含まれています",
-    'notIn'         => "には選択できない値が含まれています",
-    'ip'            => "はIPアドレスの書式として正しくありません",
-    'email'         => "はメールアドレスの書式として正しくありません",
-    'url'           => "はURLの書式として正しくありません",
-    'urlActive'     => "はアクティブなドメインではありません",
-    'alpha'         => "は半角英字で入力してください",
-    'alphaNum'      => "は半角英数字で入力してください",
-    'slug'          => "は半角英数字、もしくは「-」「_」の文字で入力してください",
-    'regex'         => "の書式が正しくありません",
-    'date'          => "は日付の書式として正しくありません",
-    'dateFormat'    => "は「%s」の書式で日付を入力してください",
-    'dateBefore'    => "は「%s」以前の日付を入力してください",
-    'dateAfter'     => "は「%s」以後の日付を入力してください",
-    'contains'      => "は「%s」を含んでいなければいけません",
-    'boolean'       => "は真偽値である必要があります",
-    'lengthBetween' => "は%d〜%d文字で入力してください",
-    'creditCard'    => "はクレジットカード番号の書式として正しくありません",
-    'lengthMin'     => "は%d文字以上入力してください",
-    'lengthMax'     => "は%d文字以内で入力してください",
-    'instanceOf'    => "は「%s」のインスタンスではありません",
+    'required'        => "を入力してください",
+    'equals'          => "は「%s」と同じ内容を入力してください",
+    'different'       => "は「%s」と異なる内容を入力してください",
+    'accepted'        => "に同意してください",
+    'numeric'         => "は数値を入力してください",
+    'integer'         => "は半角数字で入力してください",
+    'length'          => "は%d文字で入力してください",
+    'min'             => "には%sより大きな値を入力してください",
+    'max'             => "には%sより小さな値を入力してください",
+    'listContains'    => "には選択できない値が含まれています",
+    'in'              => "には選択できない値が含まれています",
+    'notIn'           => "には選択できない値が含まれています",
+    'ip'              => "はIPアドレスの書式として正しくありません",
+    'ipv4'            => "はIPv4のIPアドレスの書式として正しくありません",
+    'ipv6'            => "はIPv6のIPアドレスの書式として正しくありません",
+    'email'           => "はメールアドレスの書式として正しくありません",
+    'url'             => "はURLの書式として正しくありません",
+    'urlActive'       => "はアクティブなドメインではありません",
+    'alpha'           => "は半角英字で入力してください",
+    'alphaNum'        => "は半角英数字で入力してください",
+    'slug'            => "は半角英数字、もしくは「-」「_」の文字で入力してください",
+    'regex'           => "の書式が正しくありません",
+    'date'            => "は日付の書式として正しくありません",
+    'dateFormat'      => "は「%s」の書式で日付を入力してください",
+    'dateBefore'      => "は「%s」以前の日付を入力してください",
+    'dateAfter'       => "は「%s」以後の日付を入力してください",
+    'contains'        => "は「%s」を含んでいなければいけません",
+    'boolean'         => "は真偽値である必要があります",
+    'lengthBetween'   => "は%d〜%d文字で入力してください",
+    'creditCard'      => "はクレジットカード番号の書式として正しくありません",
+    'lengthMin'       => "は%d文字以上入力してください",
+    'lengthMax'       => "は%d文字以内で入力してください",
+    'instanceOf'      => "は「%s」のインスタンスではありません",
+    'containsUnique'  => "は重複のないように入力してください",
+    'requiredWith'    => "を入力してください",
+    'requiredWithout' => "を入力してください",
+    'subset'          => "には選択できない値が含まれています",
+    'arrayHasKeys'    => "の必要な項目が選択されていません",
 );
--- a/lang/ko.php
+++ b/lang/ko.php
@ -10,6 +10,7 @@ return array(
    'length'        => "의 길이는 %d 이어야 합니다.",
    'min'           => "은(는) %s 이상이어야 합니다.",
    'max'           => "은(는) %s 이하여야 합니다.",
+    'listContains'  => "은(는) 올바르지 않은 값을 포함하고 있습니다.",
    'in'            => "은(는) 올바르지 않은 값을 포함하고 있습니다.",
    'notIn'         => "은(는) 올바르지 않은 값을 포함하고 있습니다.",
    'ip'            => "은(는) 올바르지 않은 IP입니다.",
--- a/lang/lt.php
+++ b/lang/lt.php
@ -9,6 +9,7 @@ return array(
    'length'        => "turi būti %d ženklų ilgio",
    'min'           => "turi būti bent %s",
    'max'           => "turi būti ne daugiau kaip %s",
+    'listContains'  => "turi neteisingą vertę",
    'in'            => "turi neteisingą vertę",
    'notIn'         => "turi neteisingą vertę",
    'ip'            => "nėra teisingas IP adresas",
--- a/lang/lv.php
+++ b/lang/lv.php
@ -10,6 +10,7 @@ return array(
    'length'        => "nedrīkst būt garāks par %d simboliem",
    'min'           => "jābūt garākam par %s simboliem",
    'max'           => "jābūt īsākam par %s simboliem",
+    'listContains'  => "lauks satur nederīgu vērtību",
    'in'            => "lauks satur nederīgu vērtību",
    'notIn'         => "lauks satur nederīgu vērtību",
    'ip'            => " lauks nav derīga IP adrese",
--- a/lang/nb.php
+++ b/lang/nb.php
@ -10,6 +10,7 @@ return array(
    'length'        => "må være %d tegn langt",
    'min'           => "må være minst %s",
    'max'           => "må ikke være mer enn %s",
+    'listContains'  => "inneholder ugyldig verdi",
    'in'            => "inneholder ugyldig verdi",
    'notIn'         => "inneholder ugyldig verdi",
    'ip'            => "er ikke en gyldig IP adresse",
--- a/lang/nl.php
+++ b/lang/nl.php
@ -10,6 +10,7 @@ return array(
    'length'        => "moet minstens %d karakters lang zijn",
    'min'           => "moet minstens %s zijn",
    'max'           => "mag niet meer zijn dan %s",
+    'listContains'  => "bevat een ongeldige waarde",
    'in'            => "bevat een ongeldige waarde",
    'notIn'         => "bevat een ongeldige waarde",
    'ip'            => "is geen geldig IP-adres",
--- a/lang/nn.php
+++ b/lang/nn.php
@ -10,6 +10,7 @@ return array(
    'length'        => "må være %d tegn",
    'min'           => "må være minst %s",
    'max'           => "må ikke være mer enn %s",
+    'listContains'  => "inneholder ugyldig verdi",
    'in'            => "inneholder ugyldig verdi",
    'notIn'         => "inneholder ugyldig verdi",
    'ip'            => "er ikkje ein gyldig IP Adresse",
--- a/lang/pl.php
+++ b/lang/pl.php
@ -10,6 +10,7 @@ return array(
    'length'        => "musi być dłuższe niż %d",
    'min'           => "musi być przynajmniej %s",
    'max'           => "nie może być większe niż %s",
+    'listContains'  => "zawiera nieprawidłową wartość",
    'in'            => "zawiera nieprawidłową wartość",
    'notIn'         => "zawiera nieprawidłową wartość",
    'ip'            => "nie jest prawidłowym adresem IP",
--- a/lang/pt-br.php
+++ b/lang/pt-br.php
@ -1,34 +1,37 @@
 <?php

 return array(
-    'required'      => "é obrigatório",
-    'equals'        => "deve ser o mesmo que '%s'",
-    'different'     => "deve ser diferente de '%s'",
-    'accepted'      => "deve ser aceito",
-    'numeric'       => "deve ser um número",
-    'integer'       => "deve ser um inteiro",
-    'length'        => "deve ter %d caracteres",
-    'min'           => "deve ser maior que %s",
-    'max'           => "deve ser menor que %s",
-    'in'            => "contém um valor inválido",
-    'notIn'         => "contém um valor inválido",
-    'ip'            => "não é um IP válido",
-    'email'         => "não é um email válido",
-    'url'           => "não é uma URL válida",
-    'urlActive'     => "deve ser um domínio ativo",
-    'alpha'         => "deve conter as letras a-z",
-    'alphaNum'      => "deve conter apenas letras a-z e/ou números 0-9",
-    'slug'          => "deve conter apenas letras a-z, números 0-9, ou os caracteres - ou _",
-    'regex'         => "contém caracteres inválidos",
-    'date'          => "não é uma data válida",
-    'dateFormat'    => "deve ser uma data no formato '%s'",
-    'dateBefore'    => "deve ser uma data anterior a '%s'",
-    'dateAfter'     => "deve ser uma data posterior a '%s'",
-    'contains'      => "deve conter %s",
-    'boolean'       => "deve ser um booleano",
-    'lengthBetween' => "deve estar entre %d e %d caracteres",
-    'creditCard'    => "deve ser um numero de cartão de credito válido",
-    'lengthMin'     => "deve ter ao menos %d caracteres",
-    'lengthMax'     => "não deve exceder %d caracteres",
-    'instanceOf'    => "deve ser uma instância de '%s'"
-);
+    'required'       => "é obrigatório",
+    'equals'         => "deve ser o mesmo que '%s'",
+    'different'      => "deve ser diferente de '%s'",
+    'accepted'       => "deve ser aceito",
+    'numeric'        => "deve ser um número",
+    'integer'        => "deve ser um inteiro",
+    'length'         => "deve ter %d caracteres",
+    'min'            => "deve ser maior que %s",
+    'max'            => "deve ser menor que %s",
+    'in'             => "contém um valor inválido",
+    'notIn'          => "contém um valor inválido",
+    'ip'             => "não é um IP válido",
+    'email'          => "não é um email válido",
+    'url'            => "não é uma URL válida",
+    'urlActive'      => "deve ser um domínio ativo",
+    'alpha'          => "deve conter as letras a-z",
+    'alphaNum'       => "deve conter apenas letras a-z e/ou números 0-9",
+    'slug'           => "deve conter apenas letras a-z, números 0-9, ou os caracteres - ou _",
+    'regex'          => "contém caracteres inválidos",
+    'date'           => "não é uma data válida",
+    'dateFormat'     => "deve ser uma data no formato '%s'",
+    'dateBefore'     => "deve ser uma data anterior a '%s'",
+    'dateAfter'      => "deve ser uma data posterior a '%s'",
+    'contains'       => "deve conter %s",
+    'boolean'        => "deve ser um booleano",
+    'lengthBetween'  => "deve estar entre %d e %d caracteres",
+    'creditCard'     => "deve ser um numero de cartão de credito válido",
+    'lengthMin'      => "deve ter ao menos %d caracteres",
+    'lengthMax'      => "não deve exceder %d caracteres",
+    'instanceOf'     => "deve ser uma instância de '%s'",
+    'containsUnique' => "deve conter apenas valores únicos",
+    'subset'         => "contém um item que não está na lista",
+    'arrayHasKeys'   => "não contém todas as chaves requeridas"
+);
--- a/lang/ro.php
+++ b/lang/ro.php
@ -10,6 +10,7 @@ return array(
    'length'        => "trebuie sa fie mai lung decat %d",
    'min'           => "trebuie sa fie cel putin %s",
    'max'           => "nu trebuie sa fie mai mult de %s",
+    'listContains'  => "contine caractere invalide",
    'in'            => "contine caractere invalide",
    'notIn'         => "contine o valoare invalida",
    'ip'            => "nu este o adresa IP valida",
--- a/lang/ru.php
+++ b/lang/ru.php
@ -10,6 +10,7 @@ return array(
    'length'         => "должно быть длиннее, чем %d",
    'min'            => "должно быть не менее, чем %s",
    'max'            => "должно быть не более, чем %s",
+    'listContains'   => "содержит неверное значение",
    'in'             => "содержит неверное значение",
    'notIn'          => "содержит неверное значение",
    'ip'             => "не является валидным IP адресом",
--- a/lang/sk.php
+++ b/lang/sk.php
@ -10,6 +10,7 @@ return array(
    'length'        => "musí byť dlhý aspoň %d",
    'min'           => "musí byť dlhý minimálne %s",
    'max'           => "musí byť maximálne %s",
+    'listContains'  => "obsahuje nepovolenú hodnotu",
    'in'            => "obsahuje nepovolenú hodnotu",
    'notIn'         => "obsahuje nepovolenú hodnotu",
    'ip'            => "nie je korektná IP adresa",
--- a/lang/sl.php
+++ b/lang/sl.php
@ -0,0 +1,42 @@
+<?php
+
+return array(
+    'required'       => "potrebno",
+    'equals'         => "mora biti enak '% s'",
+    'different'      => "mora biti drugačen od '% s'",
+    'accepted'       => "mora biti označeno",
+    'numeric'        => "mora biti številka",
+    'integer'        => "mora biti celo število",
+    'length'         => "ne sme biti daljši od% d",
+    'min'            => "mora biti večji od% s",
+    'max'            => "mora biti manjši od% s",
+    'listContains'   => "vsebuje neveljavno vrednost",
+    'in'             => "vsebuje neveljavno vrednost",
+    'notIn'          => "vsebuje neveljavno vrednost",
+    'ip'             => "ni veljaven naslov IP",
+    'ipv4'           => "ni veljaven naslov IPv4",
+    'ipv6'           => "ni veljaven naslov IPv6",
+    'email'          => "ni veljaven e-poštni naslov",
+    'url'            => "ni veljaven URL",
+    'urlActive'      => "mora biti aktivna domena",
+    'alpha'          => "mora vsebovati samo črke a-z",
+    'alphaNum'       => "mora vsebovati samo črke a-z in / ali številke 0-9",
+    'slug'           => "mora vsebovati samo črke a-z, številke 0-9, črtice in podčrtaje",
+    'regex'          => "vsebuje neveljavne znake",
+    'date'           => "ni veljaven datum",
+    'dateFormat'     => "mora biti datum s formatom '% s'",
+    'dateBefore'     => "mora biti datum pred '% s'",
+    'dateAfter'      => "mora biti datum za '% s'",
+    'contains'       => "mora vsebovati% s",
+    'boolean'        => "mora biti boolean",
+    'lengthBetween'  => "mora biti med% d in% d znaki",
+    'creditCard'     => "mora biti veljavna številka kreditne kartice",
+    'lengthMin'      => "mora biti dolg vsaj% d znakov",
+    'lengthMax'      => "ne sme presegati% d znakov",
+    'instanceOf'     => "mora biti primerek '% s'",
+    'containsUnique' => "mora vsebovati samo edinstvene elemente",
+    'requiredWith'   => "je potrebno",
+    'requiredWithout'=> "je potrebno",
+    'subset'         => "vsebuje element, ki ga ni na seznamu",
+    'arrayHasKeys'   => "ne vsebuje vseh potrebnih tipk",
+);
--- a/lang/sv.php
+++ b/lang/sv.php
@ -10,25 +10,26 @@ return array(
 	'length'        => "måste vara %d tecken långt",
 	'min'           => "måste vara minst %s",
 	'max'           => "får inte vara mer än %s",
+	'listContains'  => "innehåller ogiltigt värde",
 	'in'            => "innehåller ogiltigt värde",
 	'notIn'         => "innehåller ogiltigt värde",
-	'ip'            => "är inte en giltlig IP-adress",
-	'email'         => "är inte en giltlig e-postadress",
-	'url'           => "är inte en giltlig URL",
+	'ip'            => "är inte en giltig IP-adress",
+	'email'         => "är inte en giltig e-postadress",
+	'url'           => "är inte en giltig URL",
 	'urlActive'     => "måste vara ett aktivt domännamn",
-	'alpha'         => "får bara inehålla bokstäver a-z",
-	'alphaNum'      => "får bara inehålla bokstäver a-z och/eller siffror 0-9",
-	'slug'          => "får bara inehålla bokstäver a-z och/eller siffror 0-9, bindesträck og understräck",
-	'regex'         => "inehåller ogiltliga tecken",
-	'date'          => "är inte ett giltligt datum",
+	'alpha'         => "får bara innehålla bokstäver a-z",
+	'alphaNum'      => "får bara innehålla bokstäver a-z och/eller siffror 0-9",
+	'slug'          => "får bara innehålla bokstäver a-z och/eller siffror 0-9, bindesstreck och understreck",
+	'regex'         => "innehåller ogiltiga tecken",
+	'date'          => "är inte ett giltigt datum",
 	'dateFormat'    => "måste vara ett datum med formatet '%s'",
 	'dateBefore'    => "måste vara ett datum före '%s'",
 	'dateAfter'     => "måste vara ett datum efter '%s'",
 	'contains'      => "måste innehålla %s",
 	'boolean'       => "måste vara ett booleskt värde",
 	'lengthBetween' => "måste vara mellan %d och %d tecken långt",
-	'creditCard'    => "måste vara et gyldig kredittkortnummer",
+	'creditCard'    => "måste vara ett giltigt kreditkortsnummer",
 	'lengthMin'     => "måste vara minst %d tecken långt",
-	'lengthMax'     => "får itne överstiga %d tecken",
+	'lengthMax'     => "får inte överstiga %d tecken",
 	'instanceOf'    => "måste vara en instans av '%s'"
 );
--- a/lang/th.php
+++ b/lang/th.php
@ -10,6 +10,7 @@ return array(
    'length'        => "ต้องมีความยาวมากกว่า %d",
    'min'           => "ต้องมีอย่างน้อย %s",
    'max'           => "ต้องไม่มากเกิน %s",
+    'listContains'  => "ประกอบด้วยค่าที่ไม่ถูกต้อง",
    'in'            => "ประกอบด้วยค่าที่ไม่ถูกต้อง",
    'notIn'         => "ประกอบด้วยค่าที่ไม่ถูกต้อง",
    'ip'            => "ไม่ใช่ IP ที่ถูกต้อง",
--- a/lang/tr.php
+++ b/lang/tr.php
@ -10,6 +10,7 @@ return array(
    'length'        => "en az %d adet uzunluğunda olmalı",
    'min'           => "en az böyle olmalı %s",
    'max'           => "bundan daha fazla olmalı %s",
+    'listContains'  => "geçersiz değer içeriyor",
    'in'            => "geçersiz değer içeriyor",
    'notIn'         => "geçersiz değer içeriyor",
    'ip'            => "geçerli bir IP adresi değil",
@ -28,7 +29,7 @@ return array(
    'boolean'       => "boolean olmalı",
    'lengthBetween' => "%d ve %d karakter arasında olmalı",
    'creditCard'    => "geçerli bir kredi kartı numarası olmalı",
-    "lengthMin"     => "%d katakterden fazla içermeli",
+    "lengthMin"     => "%d karakterden fazla içermeli",
    "lengthMax"     => "%d karakterden az içermeli",
    "instanceOf"    => "bunun bir örneği olmalı '%s'"
 );
--- a/lang/uk.php
+++ b/lang/uk.php
@ -10,6 +10,7 @@ return array(
    'length'        => "має бути довшим, ніж %d",
    'min'           => "має бути більше, ніж %s",
    'max'           => "повинно бути менше, ніж %s",
+    'listContains'  => "містить невірне значення",
    'in'            => "містить невірне значення",
    'notIn'         => "містить невірне значення",
    'ip'            => "не є валідною IP адресою",
--- a/lang/vi.php
+++ b/lang/vi.php
@ -10,6 +10,7 @@ return array(
    'length'        => "phải dài hơn %d",
    'min'           => "ít nhất %s",
    'max'           => "tối đa %s",
+    'listContains'  => "chứa giá trị không hợp lệ",
    'in'            => "chứa giá trị không hợp lệ",
    'notIn'         => "chứa giá trị không hợp lệ",
    'ip'            => "địa chỉ IP không hợp lệ",
--- a/lang/zh-cn.php
+++ b/lang/zh-cn.php
@ -7,9 +7,10 @@ return array(
    'accepted'      => "必须接受",
    'numeric'       => "只能是数字",
    'integer'       => "只能是整数",
-    'length'        => "长度必须大于 %d",
+    'length'        => "长度必须等于 %d",
    'min'           => "必须大于 %s",
    'max'           => "必须小于 %s",
+    'listContains'  => "无效的值",
    'in'            => "无效的值",
    'notIn'         => "无效的值",
    'ip'            => "无效IP地址",
@ -29,5 +30,11 @@ return array(
    'lengthBetween' => "长度只能介于 %d 和 %d 之间",
    'creditCard'    => "信用卡号码不正确",
    'lengthMin'     => "长度必须大于 %d",
-    'lengthMax'     => "长度必须小于 %d"
+    'lengthMax'     => "长度必须小于 %d",
+    'instanceOf'     => "必须是 '%s' 的实例",
+    'containsUnique' => "必须仅包含唯一的元素",
+    'requiredWith'   => "是必须的",
+    'requiredWithout' => "是必须的",
+    'subset'         => "包含不在列表中的项目",
+    'arrayHasKeys'   => "不包含所有必需的键",
 );
--- a/lang/zh-tw.php
+++ b/lang/zh-tw.php
@ -1,28 +1,40 @@
 <?php

 return array(
-    'required'      => "不能為空",
-    'equals'        => "必須和 '%s' 一致",
-    'different'     => "必須和 '%s' 不一致",
-    'accepted'      => "必須接受",
-    'numeric'       => "只能是數字",
-    'integer'       => "只能是整數",
-    'length'        => "長度必須大於 %d",
-    'min'           => "必須大於 %s",
-    'max'           => "必須小於 %s",
-    'in'            => "無效的值",
-    'notIn'         => "無效的值",
-    'ip'            => "無效IP地址",
-    'email'         => "無效郵箱地址",
-    'url'           => "無效的URL",
-    'urlActive'     => "必須是可用的域名",
-    'alpha'         => "只能包括英文字母(a-z)",
-    'alphaNum'      => "只能包括英文字母(a-z)和數字(0-9)",
-    'slug'          => "只能包括英文字母(a-z)、數字(0-9)、破折號和下劃線",
-    'regex'         => "無效格式",
-    'date'          => "無效的日期",
-    'dateFormat'    => "日期的格式應該為 '%s'",
-    'dateBefore'    => "日期必須在 '%s' 之前",
-    'dateAfter'     => "日期必須在 '%s' 之後",
-    'contains'  => "必須包含 %s"
+  'required'      => "不能為空",
+  'equals'        => "必須和 '%s' 一致",
+  'different'     => "必須和 '%s' 不一致",
+  'accepted'      => "必須接受",
+  'numeric'       => "只能是數字",
+  'integer'       => "只能是整數",
+  'length'        => "長度必須大於 %d",
+  'min'           => "必須大於 %s",
+  'max'           => "必須小於 %s",
+  'listContains'  => "無效的值",
+  'in'            => "無效的值",
+  'notIn'         => "無效的值",
+  'ip'            => "無效IP地址",
+  'email'         => "無效郵箱地址",
+  'url'           => "無效的URL",
+  'urlActive'     => "必須是可用的域名",
+  'alpha'         => "只能包括英文字母(a-z)",
+  'alphaNum'      => "只能包括英文字母(a-z)和數字(0-9)",
+  'slug'          => "只能包括英文字母(a-z)、數字(0-9)、破折號和下劃線",
+  'regex'         => "無效格式",
+  'date'          => "無效的日期",
+  'dateFormat'    => "日期的格式應該為 '%s'",
+  'dateBefore'    => "日期必須在 '%s' 之前",
+  'dateAfter'     => "日期必須在 '%s' 之後",
+  'contains'      => "必須包含 %s",
+  'boolean'       => "必須是真或假",
+  'lengthBetween' => "長度只能介於 %d 和 %d 之間",
+  'creditCard'    => "信用卡號碼不正確",
+  'lengthMin'     => "長度必須大於 %d",
+  'lengthMax'     => "長度必須小於 %d",
+  'instanceOf'     => "必須是 '%s' 的實例",
+  'containsUnique' => "必須僅包含唯一的元素",
+  'requiredWith'   => "是必須的",
+  'requiredWithout' => "是必須的",
+  'subset'         => "包含不在列表中的項目",
+  'arrayHasKeys'   => "不包含所有必需的鍵",
 );
--- a/phpunit.xml
+++ b/phpunit.xml
@ -7,7 +7,6 @@
         convertWarningsToExceptions="true"
         processIsolation="false"
         stopOnFailure="false"
-         syntaxCheck="false"
         bootstrap="tests/bootstrap.php"
 >
  <testsuites>
@ -15,12 +14,4 @@
      <directory suffix="Test.php">tests/Valitron</directory>
    </testsuite>
  </testsuites>
-  <filter>
-    <whitelist>
-      <directory suffix=".php">src/</directory>
-    </whitelist>
-      <blacklist>
-        <directory suffix=".php">vendor/</directory>
-      </blacklist>
-    </filter>
 </phpunit>
--- a/src/Valitron/Validator.php
+++ b/src/Valitron/Validator.php
@ -83,6 +83,11 @@ class Validator
     */
    protected $stop_on_first_fail = false;

+    /**
+     * @var bool
+     */
+    protected $prepend_labels = true;
+
    /**
     * Setup validation
     *
@ -144,6 +149,14 @@ class Validator
        return static::$_langDir ?: dirname(dirname(__DIR__)) . '/lang';
    }

+    /**
+     * @param bool $prepend_labels
+     */
+    public function setPrependLabels($prepend_labels = true)
+    {
+        $this->prepend_labels = $prepend_labels;
+    }
+
    /**
     * Required field validator
     *
@ -159,9 +172,7 @@ class Validator
            return $find[1];
        }

-        if (is_null($value)) {
-            return false;
-        } elseif (is_string($value) && trim($value) === '') {
+        if (is_null($value) || (is_string($value) && trim($value) === '')) {
            return false;
        }

@ -409,9 +420,13 @@ class Validator
     */
    protected function validateIn($field, $value, $params)
    {
-        $isAssoc = array_values($params[0]) !== $params[0];
-        if ($isAssoc) {
-            $params[0] = array_keys($params[0]);
+        $forceAsAssociative = false;
+        if (isset($params[2])) {
+            $forceAsAssociative = (bool) $params[2];
+        }
+
+        if ($forceAsAssociative || $this->isAssociativeArray($params[0])) {
+           $params[0] = array_keys($params[0]);
        }

        $strict = false;
@ -422,6 +437,33 @@ class Validator
        return in_array($value, $params[0], $strict);
    }

+    /**
+     * Validate a field is contained within a list of values
+     *
+     * @param  string $field
+     * @param  mixed  $value
+     * @param  array  $params
+     * @return bool
+     */
+    protected function validateListContains($field, $value, $params)
+    {
+        $forceAsAssociative = false;
+        if (isset($params[2])) {
+            $forceAsAssociative = (bool) $params[2];
+        }
+
+        if ($forceAsAssociative || $this->isAssociativeArray($value)) {
+            $value = array_keys($value);
+        }
+
+        $strict = false;
+        if (isset($params[1])) {
+            $strict = $params[1];
+        }
+
+        return in_array($params[0], $value, $strict);
+    }
+
    /**
     * Validate a field is not contained within a list of values
     *
@ -489,7 +531,7 @@ class Validator
        if (!is_array($params[0])) {
            $params[0] = array($params[0]);
        }
-        if (is_scalar($value)) {
+        if (is_scalar($value) || is_null($value)) {
            return $this->validateIn($field, $value, $params);
        }

@ -588,12 +630,17 @@ class Validator
     */
    protected function validateEmailDNS($field, $value)
    {
+        if (!is_string($value)) {
+            return false;
+        }
+
        if ($this->validateEmail($field, $value)) {
            $domain = ltrim(stristr($value, '@'), '@') . '.';
            if (function_exists('idn_to_ascii') && defined('INTL_IDNA_VARIANT_UTS46')) {
                $domain = idn_to_ascii($domain, 0, INTL_IDNA_VARIANT_UTS46);
            }
-            return checkdnsrr($domain, 'ANY');
+
+            return checkdnsrr($domain, 'MX');
        }

        return false;
@ -608,6 +655,10 @@ class Validator
     */
    protected function validateUrl($field, $value)
    {
+        if (!is_string($value)) {
+            return false;
+        }
+
        foreach ($this->validUrlPrefixes as $prefix) {
            if (strpos($value, $prefix) !== false) {
                return filter_var($value, \FILTER_VALIDATE_URL) !== false;
@ -626,6 +677,10 @@ class Validator
     */
    protected function validateUrlActive($field, $value)
    {
+        if (!is_string($value)) {
+            return false;
+        }
+
        foreach ($this->validUrlPrefixes as $prefix) {
            if (strpos($value, $prefix) !== false) {
                $host = parse_url(strtolower($value), PHP_URL_HOST);
@ -854,11 +909,9 @@ class Validator
                } elseif (isset($cards)) {
                    // if we have cards, check our users card against only the ones we have
                    foreach ($cards as $card) {
-                        if (in_array($card, array_keys($cardRegex))) {
+                        if (in_array($card, array_keys($cardRegex)) && preg_match($cardRegex[$card], $value) === 1) {
                            // if the card is valid, we want to stop looping
-                            if (preg_match($cardRegex[$card], $value) === 1) {
-                                return true;
-                            }
+                            return true;
                        }
                    }
                } else {
@ -897,6 +950,94 @@ class Validator
        return $isInstanceOf;
    }

+    /**
+     * Validates whether or not a field is required based on whether or not other fields are present.
+     *
+     * @param string $field name of the field in the data array
+     * @param mixed $value value of this field
+     * @param array $params parameters for this rule
+     * @param array $fields full list of data to be validated
+     * @return bool
+     */
+    protected function validateRequiredWith($field, $value, $params, $fields)
+    {
+        $conditionallyReq = false;
+        // if we actually have conditionally required with fields to check against
+        if (isset($params[0])) {
+            // convert single value to array if it isn't already
+            $reqParams = is_array($params[0]) ? $params[0] : array($params[0]);
+            // check for the flag indicating if all fields are required
+            $allRequired = isset($params[1]) && (bool)$params[1];
+            $emptyFields = 0;
+            foreach ($reqParams as $requiredField) {
+                // check the field is set, not null, and not the empty string
+                list($requiredFieldValue, $multiple) = $this->getPart($fields, explode('.', $requiredField));
+                if (isset($requiredFieldValue) && (!is_string($requiredFieldValue) || trim($requiredFieldValue) !== '')) {
+                    if (!$allRequired) {
+                        $conditionallyReq = true;
+                        break;
+                    } else {
+                        $emptyFields++;
+                    }
+                }
+            }
+            // if all required fields are present in strict mode, we're requiring it
+            if ($allRequired && $emptyFields === count($reqParams)) {
+                $conditionallyReq = true;
+            }
+        }
+        // if we have conditionally required fields
+        if ($conditionallyReq && (is_null($value) ||
+                is_string($value) && trim($value) === '')) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Validates whether or not a field is required based on whether or not other fields are present.
+     *
+     * @param string $field name of the field in the data array
+     * @param mixed $value value of this field
+     * @param array $params parameters for this rule
+     * @param array $fields full list of data to be validated
+     * @return bool
+     */
+    protected function validateRequiredWithout($field, $value, $params, $fields)
+    {
+        $conditionallyReq = false;
+        // if we actually have conditionally required with fields to check against
+        if (isset($params[0])) {
+            // convert single value to array if it isn't already
+            $reqParams = is_array($params[0]) ? $params[0] : array($params[0]);
+            // check for the flag indicating if all fields are required
+            $allEmpty = isset($params[1]) && (bool)$params[1];
+            $filledFields = 0;
+            foreach ($reqParams as $requiredField) {
+                // check the field is NOT set, null, or the empty string, in which case we are requiring this value be present
+                list($requiredFieldValue, $multiple) = $this->getPart($fields, explode('.', $requiredField));
+                if (!isset($requiredFieldValue) || (is_string($requiredFieldValue) && trim($requiredFieldValue) === '')) {
+                    if (!$allEmpty) {
+                        $conditionallyReq = true;
+                        break;
+                    } else {
+                        $filledFields++;
+                    }
+                }
+            }
+            // if all fields were empty, then we're requiring this in strict mode
+            if ($allEmpty && $filledFields === count($reqParams)) {
+                $conditionallyReq = true;
+            }
+        }
+        // if we have conditionally required fields
+        if ($conditionallyReq && (is_null($value) ||
+                is_string($value) && trim($value) === '')) {
+            return false;
+        }
+        return true;
+    }
+
    /**
     * Validate optional field
     *
@ -911,6 +1052,23 @@ class Validator
        return true;
    }

+    protected function validateArrayHasKeys($field, $value, $params)
+    {
+        if (!is_array($value) || !isset($params[0])) {
+            return false;
+        }
+        $requiredFields = $params[0];
+        if (count($requiredFields) === 0) {
+            return false;
+        }
+        foreach ($requiredFields as $fieldName) {
+            if (!array_key_exists($fieldName, $value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
    /**
     * Get array of fields and data
     *
@ -961,10 +1119,8 @@ class Validator
                }
            }
            // Use custom label instead of field name if set
-            if (is_string($params[0])) {
-                if (isset($this->_labels[$param])) {
-                    $param = $this->_labels[$param];
-                }
+            if (is_string($params[0]) && isset($this->_labels[$param])) {
+                $param = $this->_labels[$param];
            }
            $values[] = $param;
        }
@ -1039,6 +1195,27 @@ class Validator
        }
    }

+    private function validationMustBeExcecuted($validation, $field, $values, $multiple){
+        //always excecute requiredWith(out) rules
+        if (in_array($validation['rule'], array('requiredWith', 'requiredWithout'))){
+            return true;
+        }
+
+        //do not execute if the field is optional and not set
+        if($this->hasRule('optional', $field) && ! isset($values)){
+            return false;
+        }
+
+        //ignore empty input, except for required and accepted rule
+        if (! $this->hasRule('required', $field) && ! in_array($validation['rule'], array('required', 'accepted'))){
+            if($multiple){
+                return count($values) != 0;
+            }
+            return (isset($values) && $values !== '');
+        }
+
+        return true;
+    }
    /**
     * Run validations and return boolean result
     *
@ -1051,14 +1228,7 @@ class Validator
            foreach ($v['fields'] as $field) {
                list($values, $multiple) = $this->getPart($this->_fields, explode('.', $field), false);

-                // Don't validate if the field is not required and the value is empty
-                if ($this->hasRule('optional', $field) && isset($values)) {
-                    //Continue with execution below if statement
-                } elseif (
-                    $v['rule'] !== 'required' && !$this->hasRule('required', $field) &&
-                    $v['rule'] !== 'accepted' &&
-                    (!isset($values) || $values === '' || ($multiple && count($values) == 0))
-                ) {
+                if (! $this->validationMustBeExcecuted($v, $field, $values, $multiple)){
                    continue;
                }

@ -1136,10 +1306,8 @@ class Validator
    protected function hasRule($name, $field)
    {
        foreach ($this->_validations as $validation) {
-            if ($validation['rule'] == $name) {
-                if (in_array($field, $validation['fields'])) {
-                    return true;
-                }
+            if ($validation['rule'] == $name && in_array($field, $validation['fields'])) {
+                return true;
            }
        }

@ -1229,7 +1397,7 @@ class Validator
    /**
     * Convenience method to add a single validation rule
     *
-     * @param string|callback $rule
+     * @param string|callable $rule
     * @param array|string $fields
     * @return Validator
     * @throws \InvalidArgumentException
@ -1329,7 +1497,9 @@ class Validator
                }
            }
        } else {
-            $message = str_replace('{field}', ucwords(str_replace('_', ' ', $field)), $message);
+            $message = $this->prepend_labels
+                ? str_replace('{field}', ucwords(str_replace('_', ' ', $field)), $message)
+                : str_replace('{field} ', '', $message);
        }

        return $message;
@ -1416,4 +1586,9 @@ class Validator
            $me->mapFieldRules($field, $rules[$field]);
        }, array_keys($rules));
    }
+
+    private function isAssociativeArray($input){
+        //array contains at least one key that's not an can not be cast to an integer
+        return count(array_filter(array_keys($input), 'is_string')) > 0;
+    }
 }
--- a/tests/Valitron/BaseTestCase.php
+++ b/tests/Valitron/BaseTestCase.php
@ -4,10 +4,8 @@ use PHPUnit\Framework\TestCase;

 class BaseTestCase extends TestCase
 {
-	public function setUp()
-	{
-	}

+/*
 	public function tearDown()
 	{
 		$this->resetProperty('_lang');
@ -23,4 +21,5 @@ class BaseTestCase extends TestCase
 		$prop->setValue($value);
 		$prop->setAccessible(false);
 	}
+*/
 }
--- a/tests/Valitron/ErrorMessagesTest.php
+++ b/tests/Valitron/ErrorMessagesTest.php
@ -12,6 +12,19 @@ class ErrorMessagesTest extends BaseTestCase
        $this->assertSame(array("Name is required"), $v->errors('name'));
    }

+    /**
+     * Test the disabling of prepending the field labels
+     * to error messages.
+     */
+    public function testErrorMessageExcludeFieldName()
+    {
+        $v = new Validator(array());
+        $v->setPrependLabels(false);
+        $v->rule('required', 'name');
+        $v->validate();
+        $this->assertSame(array("is required"), $v->errors('name'));
+    }
+
    public function testAccurateErrorMessageParams()
    {
        $v = new Validator(array('num' => 5));
--- a/tests/Valitron/LangTest.php
+++ b/tests/Valitron/LangTest.php
@ -15,8 +15,8 @@ class LangTest extends BaseTestCase
    {
    	$lang = 'ar';
    	Validator::lang($lang);
-    	$validator = new Validator(array());
    	$this->assertEquals($lang, Validator::lang());
+        Validator::lang('en');
 	}

 	/**
@ -42,13 +42,15 @@ class LangTest extends BaseTestCase
 		$this->assertEquals(realpath($this->getLangDir()), realpath(Validator::langDir()));
 	}

-	/**
-     * @expectedException InvalidArgumentException
-     * @expectedExceptionMessage Fail to load language file '/this/dir/does/not/exists/en.php'
-     */
+
 	public function testLangException()
 	{
+        try{
 		new Validator(array(), array(), 'en', '/this/dir/does/not/exists');
+        } catch (Exception $exception){
+            $this->assertInstanceOf("InvalidArgumentException", $exception);
+            $this->assertEquals("Fail to load language file '/this/dir/does/not/exists/en.php'", $exception->getMessage());
+        }
 	}


--- a/tests/Valitron/StaticVsInstanceTest.php
+++ b/tests/Valitron/StaticVsInstanceTest.php
@ -10,6 +10,7 @@ class StaticVsInstanceTest extends BaseTestCase
 		$this->assertEquals(
 		    'ar', Validator::lang(), 'instance defined lang should not replace static global lang'
        );
+		Validator::lang('en');
 	}

 	/**
--- a/tests/Valitron/ValidateTest.php
+++ b/tests/Valitron/ValidateTest.php
@ -484,7 +484,7 @@ class ValidateTest extends BaseTestCase
        $v->rule('lengthMin', 'str', 4);
        $this->assertTrue($v->validate());
    }
-    
+
    public function testLengthMinValidAltSyntax()
    {
        $v = new Valitron\Validator(array('username' => 'martha'));
@ -726,6 +726,35 @@ class ValidateTest extends BaseTestCase
        $this->assertFalse($v->validate());
    }

+    public function testListContainsValid()
+    {
+        $v = new Validator(array('color' => array('blue', 'green', 'red', 'yellow')));
+        $v->rule('listContains', 'color', 'red');
+        $this->assertTrue($v->validate());
+    }
+
+    public function testListContainsValidAltSyntax()
+    {
+        $v = new Validator(array('color' => array('blue', 'green', 'red')));
+        $v->rules(array(
+            'listContains' => array(
+                array('color', 'red')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testListContainsInvalidAltSyntax()
+    {
+        $v = new Validator(array('color' => array('blue', 'green', 'red')));
+        $v->rules(array(
+            'listContains' => array(
+                array('color', 'yellow')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
    public function testInValid()
    {
        $v = new Validator(array('color' => 'green'));
@ -951,6 +980,7 @@ class ValidateTest extends BaseTestCase
                array('color', array('blue', 'green', 'red', 'yellow'))
            )
        ));
+        $this->assertFalse($v->validate());
    }

    public function testAsciiValid()
@ -1720,6 +1750,15 @@ class ValidateTest extends BaseTestCase
        $this->assertFalse($v->validate());
    }

+    public function testSubsetAcceptNullValue()
+    {
+    		// rule value equals null
+        $v = new Validator(array('test_field' => null));
+        $v->rule('required', 'test_field');
+        $v->rule('subset', 'test_field', array('black', 45));
+        $this->assertFalse($v->validate());
+    }
+
    public function testContainsUniqueValid()
    {
        // numeric values
@ -2220,6 +2259,338 @@ class ValidateTest extends BaseTestCase
        $this->assertFalse($v->validate());
    }

+    public function testRequiredWithValid()
+    {
+        $v = new Validator(array('username' => 'tester', 'password' => 'mypassword'));
+        $v->rule('requiredWith', 'password', 'username');
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithValidNoParams()
+    {
+        $v = new Validator(array());
+        $v->rule('requiredWith', 'password', 'username');
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithValidEmptyString()
+    {
+        $v = new Validator(array('username' => ''));
+        $v->rule('requiredWith', 'password', 'username');
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithValidNullValue()
+    {
+        $v = new Validator(array('username' => null));
+        $v->rule('requiredWith', 'password', 'username');
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithValidAltSyntax()
+    {
+        $v = new Validator(array('username' => 'tester', 'password' => 'mypassword'));
+        $v->rules(array(
+            'requiredWith' => array(
+                array('password', 'username')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithValidArray()
+    {
+        $v = new Validator(array('username' => 'tester', 'email' => 'test@test.com', 'password' => 'mypassword'));
+        $v->rule('requiredWith', 'password', array('username', 'email'));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithStrictValidArray()
+    {
+        $v = new Validator(array('username' => 'tester', 'email' => 'test@test.com', 'password' => 'mypassword'));
+        $v->rule('requiredWith', 'password', array('username', 'email'), true);
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithStrictInvalidArray()
+    {
+        $v = new Validator(array('email' => 'test@test.com', 'username' => 'batman'));
+        $v->rule('requiredWith', 'password', array('username', 'email'), true);
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithStrictValidArrayNotRequired()
+    {
+        $v = new Validator(array('username' => 'tester', 'email' => 'test@test.com'));
+        $v->rule('requiredWith', 'password', array('username', 'email', 'nickname'), true);
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithStrictValidArrayEmptyValues()
+    {
+        $v = new Validator(array('email' => '', 'username' => null));
+        $v->rule('requiredWith', 'password', array('username', 'email'), true);
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithStrictInvalidArraySingleValue()
+    {
+        $v = new Validator(array('email' => 'tester', 'username' => null));
+        $v->rule('requiredWith', 'password', array('username', 'email'), true);
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithValidArrayAltSyntax()
+    {
+        $v = new Validator(array('password' => 'mypassword'));
+        $v->rules(array(
+            'requiredWith' => array(
+                array('password', array('username', 'email'))
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithInvalid()
+    {
+        $v = new Validator(array('username' => 'tester'));
+        $v->rule('requiredWith', 'password', 'username');
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithInvalidAltSyntax()
+    {
+        $v = new Validator(array('username' => 'tester'));
+        $v->rules(array(
+            'requiredWith' => array(
+                array('password', 'username')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithInvalidArray()
+    {
+        $v = new Validator(array('email' => 'test@test.com', 'nickname' => 'kevin'));
+        $v->rule('requiredWith', 'password', array('username', 'email', 'nickname'));
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithInvalidStrictArray()
+    {
+        $v = new Validator(array('email' => 'test@test.com', 'username' => 'batman', 'nickname' => 'james'));
+        $v->rule('requiredWith', 'password', array('username', 'email', 'nickname'), true);
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithInvalidArrayAltSyntax()
+    {
+        $v = new Validator(array('username' => 'tester', 'email' => 'test@test.com'));
+        $v->rules(array(
+            'requiredWith' => array(
+                array('password', array('username', 'email', 'nickname'))
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithStrictInvalidArrayAltSyntax()
+    {
+        $v = new Validator(array('username' => 'tester', 'email' => 'test@test.com', 'nickname' => 'joseph'));
+        $v->rules(array(
+            'requiredWith' => array(
+                array('password', array('username', 'email', 'nickname'), true)
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
+    // required without tests
+
+    public function testRequiredWithoutValid()
+    {
+        $v = new Validator(array('password' => 'mypassword'));
+        $v->rule('requiredWithout', 'password', 'username');
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithoutInvalidNotPresent()
+    {
+        $v = new Validator(array());
+        $v->rule('requiredWithout', 'password', 'username');
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithoutValidEmptyString()
+    {
+        $v = new Validator(array('username' => '', 'password' => 'mypassword'));
+        $v->rule('requiredWithout', 'password', 'username');
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithoutInvalidEmptyStringNotPresent()
+    {
+        $v = new Validator(array('username' => ''));
+        $v->rule('requiredWithout', 'password', 'username');
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithoutValidNullValue()
+    {
+        $v = new Validator(array('username' => null, 'password' => 'mypassword'));
+        $v->rule('requiredWithout', 'password', 'username');
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithoutInvlidNullValueNotPresent()
+    {
+        $v = new Validator(array('username' => null));
+        $v->rule('requiredWithout', 'password', 'username');
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithoutValidAltSyntax()
+    {
+        $v = new Validator(array('password' => 'mypassword'));
+        $v->rules(array(
+            'requiredWithout' => array(
+                array('password', 'username')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithoutInvalidAltSyntaxNotPresent()
+    {
+        $v = new Validator(array());
+        $v->rules(array(
+            'requiredWithout' => array(
+                array('password', 'username')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithoutValidArray()
+    {
+        $v = new Validator(array('password' => 'mypassword'));
+        $v->rule('requiredWithout', 'password', array('username', 'email'));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithoutInvalidArrayNotPresent()
+    {
+        $v = new Validator(array());
+        $v->rule('requiredWithout', 'password', array('username', 'email'));
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithoutValidArrayPartial()
+    {
+        $v = new Validator(array('password' => 'mypassword', 'email' => 'test@test.com'));
+        $v->rule('requiredWithout', 'password', array('username', 'email'));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithoutInvalidArrayPartial()
+    {
+        $v = new Validator(array('email' => 'test@test.com'));
+        $v->rule('requiredWithout', 'password', array('username', 'email'));
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithoutValidArrayStrict()
+    {
+        $v = new Validator(array('email' => 'test@test.com'));
+        $v->rule('requiredWithout', 'password', array('username', 'email'), true);
+        $this->assertTrue($v->validate());
+    }
+
+    public function testRequiredWithoutInvalidArrayStrict()
+    {
+        $v = new Validator(array());
+        $v->rule('requiredWithout', 'password', array('username', 'email'), true);
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithoutInvalidArrayNotProvided()
+    {
+        $v = new Validator(array('email' => 'test@test.com'));
+        $v->rule('requiredWithout', 'password', array('username', 'email'));
+        $this->assertFalse($v->validate());
+    }
+
+    public function testRequiredWithoutValidArrayAltSyntax()
+    {
+        $v = new Validator(array('password' => 'mypassword'));
+        $v->rules(array(
+            'requiredWithout' => array(
+                array('password', array('username', 'email'))
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testConditionallyRequiredAuthSampleToken()
+    {
+        $v = new Validator(array('token' => 'ajkdhieyf2834fsuhf8934y89'));
+        $v->rule('requiredWithout', 'token', array('email', 'password'));
+        $v->rule('requiredWith', 'password', 'email');
+        $v->rule('email', 'email');
+        $v->rule('optional', 'email');
+        $this->assertTrue($v->validate());
+    }
+
+    public function testConditionallyRequiredAuthSampleMissingPassword()
+    {
+        $v = new Validator(array('email' => 'test@test.com'));
+        $v->rule('requiredWithout', 'token', array('email', 'password'));
+        $v->rule('requiredWith', 'password', 'email');
+        $v->rule('email', 'email');
+        $v->rule('optional', 'email');
+        $this->assertFalse($v->validate());
+    }
+
+    public function testConditionallyRequiredAuthSampleTokenAltSyntax()
+    {
+        $v = new Validator(array('token' => 'ajkdhieyf2834fsuhf8934y89'));
+        $v->rules(array(
+            'requiredWithout' => array(
+                array('token', array('email', 'password'))
+            ),
+            'requiredWith' => array(
+                array('password', array('email'))
+            ),
+            'email' => array(
+                array('email')
+            ),
+            'optional' => array(
+                array('email')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testConditionallyRequiredAuthSampleEmailPasswordAltSyntax()
+    {
+        $v = new Validator(array('email' => 'test@test.com', 'password' => 'mypassword'));
+        $v->rules(array(
+            'requiredWithout' => array(
+                array('token', array('email', 'password'))
+            ),
+            'requiredWith' => array(
+                array('password', array('email'))
+            ),
+            'email' => array(
+                array('email')
+            ),
+            'optional' => array(
+                array('email')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
    /**
     * @dataProvider dataProviderFor_testError
     */
@ -2483,6 +2854,112 @@ class ValidateTest extends BaseTestCase
        $v->rule('date', 'data.*.foo');
        $this->assertFalse($v->validate());
    }
+
+    public function testArrayHasKeysTrueIfAllFieldsExist()
+    {
+        $v = new Validator(array(
+            'address' => array(
+                'name' => 'Jane Doe',
+                'street' => 'Doe Square',
+                'city' => 'Doe D.C.'
+            )
+        ));
+        $v->rule('arrayHasKeys', 'address', array('name', 'street', 'city'));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testArrayHasKeysFalseOnMissingField()
+    {
+        $v = new Validator(array(
+            'address' => array(
+                'name' => 'Jane Doe',
+                'street' => 'Doe Square'
+            )
+        ));
+        $v->rule('arrayHasKeys', 'address', array('name', 'street', 'city'));
+        $this->assertFalse($v->validate());
+    }
+
+    public function testArrayHasKeysFalseOnNonArray()
+    {
+        $v = new Validator(array(
+            'address' => 'Jane Doe, Doe Square'
+        ));
+        $v->rule('arrayHasKeys', 'address', array('name', 'street', 'city'));
+        $this->assertFalse($v->validate());
+    }
+
+    public function testArrayHasKeysFalseOnEmptyRequiredFields()
+    {
+        $v = new Validator(array(
+            'address' => array(
+                'lat' => 77.547,
+                'lon' => 16.337
+            )
+        ));
+        $v->rule('arrayHasKeys', 'address', array());
+        $this->assertFalse($v->validate());
+    }
+
+    public function testArrayHasKeysFalseOnUnspecifiedRequiredFields()
+    {
+        $v = new Validator(array(
+            'address' => array(
+                'lat' => 77.547,
+                'lon' => 16.337
+            )
+        ));
+        $v->rule('arrayHasKeys', 'address');
+        $this->assertFalse($v->validate());
+    }
+
+    public function testArrayHasKeysTrueIfMissingAndOptional()
+    {
+        $v = new Validator(array());
+        $v->rule('arrayHasKeys', 'address', array('name', 'street', 'city'));
+        $v->rule('optional', 'address');
+        $this->assertTrue($v->validate());
+    }
+
+    /**
+     *
+     * @see https://github.com/vlucas/valitron/issues/332
+     */
+    public function testInRuleSearchesValuesForNumericArray(){
+
+        $v = new Valitron\Validator(array('color' => 'purple'));
+
+        $v->rules(array(
+            'in' => array(
+                array('color', array(3=>'green', 2=>'purple'))
+            )
+        ));
+
+        $this->assertTrue($v->validate());
+    }
+
+    public function testInRuleSearchesKeysForAssociativeArray(){
+        $v = new Valitron\Validator(array('color' => 'c-2'));
+
+        $v->rules(array(
+            'in' => array(
+                array('color', array('c-3'=>'green', 'c-2'=>'purple'))
+            )
+        ));
+
+        $this->assertTrue($v->validate());
+    }
+
+    public function testInRuleSearchesKeysWhenForcedTo(){
+        $v = new Valitron\Validator(array('color' => 2));
+
+        $v->rules(array(
+            'in' => array(
+                array('color', array('3'=>'green', '2'=>'purple'), null, true)
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
 }

 function sampleFunctionCallback($field, $value, array $params)
Author	SHA1	Message	Date
Willem Wollebrants	fadce39f5f	Merge pull request #365 from blueyestar/master added missing translation for zh-cn and zh-tw	2022-10-14 13:54:24 +02:00
Willem Wollebrants	5659b0a942	Merge pull request #364 from metakin/fix-typo typo fix	2022-10-14 13:53:54 +02:00
Willem Wollebrants	fdc64d193a	Merge pull request #359 from mehdihasanpour/add-persian add persian language	2022-10-14 13:52:39 +02:00
Willem Wollebrants	0cbc5834b0	Merge pull request #350 from eugene-borovov/requirewith-dot-notation Added dot notation to requireWith(out)	2022-10-14 13:52:03 +02:00
Justin Li	1b86b4f454	added missing translation for zh-cn and zh-tw	2022-10-11 11:56:38 -04:00
metakin	fbb596d220	typo fix	2022-10-11 03:22:02 +03:00
Willem Wollebrants	57a9f68f22	Merge pull request #363 from Tautve/issue_357 Fixed Issue #357	2022-10-03 09:50:30 +02:00
tautvydaskarvelis	fd902d1def	Issue #357	2022-10-01 10:06:52 +03:00
mehdi hasanpour	ac960d625f	add persian language	2022-07-02 15:59:33 +04:30
Willem Wollebrants	d0fb8ee84c	Merge pull request #354 from aldinhro/patch-1 Update sv.php	2022-03-16 10:16:07 +01:00
Aldin Hro	94c97e3e8e	Update sv.php Added correct translations	2022-03-16 10:10:25 +01:00
Willem Wollebrants	9bf11f4374	Merge pull request #351 from hiroy/add-japanese-messages Add Japanese messages for some rules	2021-12-07 09:05:12 +01:00
Hiroyuki Yamaoka	b619ef16ba	Add Japanese messages for some rules	2021-12-07 14:18:08 +09:00
Eugene Borovov	b4e0d07495	Added dot notation to requireWith(out)	2021-11-21 01:55:32 +07:00
Willem Wollebrants	5ebd5d7af8	Merge pull request #344 from vlucas/issue-326 Test against PHP 8	2021-07-08 18:18:03 +02:00
Willem Wollebrants	f189549d2d	make tests compatible with phpunit for php8	2021-07-07 11:55:52 +02:00
Willem Wollebrants	fe2ca630fb	make tests compatible with phpunit for php8	2021-07-07 11:52:59 +02:00
Willem Wollebrants	035eca3093	make tests compatible with phpunit for php8	2021-07-07 11:47:59 +02:00
Willem Wollebrants	da91bdea70	make tests compatible with phpunit for php8	2021-07-07 11:44:08 +02:00
Willem Wollebrants	ba90097aa5	Merge pull request #343 from vlucas/issue-332 detect numeric array when keys are out of order , fixes #332	2021-07-06 14:22:56 +02:00
Willem Wollebrants	d12a77deed	check first (#332 )	2021-07-06 14:16:59 +02:00
Willem Wollebrants	be8cb9e074	add parameter to force in and listContains to look at array keys	2021-07-06 10:58:22 +02:00
Willem Wollebrants	500472808c	detect numeric array when keys are out of order (#332 )	2021-07-05 22:14:24 +02:00
Willem Wollebrants	567fbb9965	Merge pull request #340 from euantorano/patch-1 Update build status badge	2021-07-05 18:42:08 +02:00
Willem Wollebrants	ae5a778541	Merge pull request #342 from vlucas/issue-328 Correct label for 'length' in zh-cn (#328)	2021-07-05 18:41:34 +02:00
Willem Wollebrants	1c0674c23f	Correct label for 'length' in zh-cn (#328 )	2021-07-05 18:40:18 +02:00
Willem Wollebrants	4c7d0070dd	Merge pull request #341 from vlucas/issue-335 add missing assertion to testNotInInvalidAltSyntax (#335)	2021-07-05 18:34:54 +02:00
Willem Wollebrants	33148fa4ed	add missing assertion to testNotInInvalidAltSyntax (#335 )	2021-07-05 18:33:50 +02:00
Euan Torano	f0c48c4adf	Update build status badge As GitHub Actions now runs CI, the build status badge must be from GitHub Actions.	2021-07-05 17:29:12 +01:00
Willem Wollebrants	0282ca420b	Merge pull request #338 from euantorano/feature/github-actions Fixed #337 - add GitHub Actions workflow to run tests	2021-07-05 18:25:56 +02:00
Euan Torano	5deb47049a	Added GitHub workflow file, removed Travis CI file. Changed how email DNS validation works to only check MX record.	2021-06-17 13:01:49 +01:00
Vance Lucas	f7e662e3c0	Merge pull request #334 from joebordes/sonarqube merge IF statement with enclosing one (sonarqube static analysis)	2021-05-12 14:47:47 -05:00
joebordes	6b3c5ae608	merge IF statement with enclosing one (sonarqube static analysis)	2021-05-12 21:21:46 +02:00
Willem Wollebrants	81515dcc95	Merge pull request #325 from TomOudeRengerink/disable-auto-prepend-field-label Allow disabling of auto prepending the field labels.	2020-12-01 12:14:45 +01:00
Tom Oude Rengerink	9f29a1b99a	Added test for prepending field labels	2020-10-26 12:45:34 +01:00
Tom Oude Rengerink	bfa24585de	Changed method name for readability and writting some docs.	2020-10-23 16:29:08 +02:00
Tom Oude Rengerink	6a6810e25c	Removed some PHP Doc blocks generated by IDEA	2020-10-23 16:16:25 +02:00
Tom Oude Rengerink	128097ea16	Allow disabling of auto prepending the field labels shown in the error message.	2020-10-23 16:11:20 +02:00
Willem Wollebrants	9268adeeb4	Merge pull request #316 from euantorano/patch-1 Fix invalid opening bracket for arrayHasKeys example	2020-07-10 10:55:05 +02:00
Euan	a204228146	Fix mismatched open array for arrayHasKeys.	2020-07-07 16:08:30 +01:00
Willem Wollebrants	4af076d19f	Merge pull request #312 from PowerPan/sl Add SL	2020-05-14 16:50:07 +02:00
Johannes Rudolph	3d2b0ef5f7	Add SL	2020-05-04 13:34:58 +02:00
Willem Wollebrants	43e9393009	Merge pull request #310 from sergiy-petrov/patch-1 test agains php 7.4	2020-03-05 20:31:19 +01:00
sergiy-petrov	7747441139	test agains php 7.4	2020-03-05 15:30:36 +02:00
Willem Wollebrants	87f830e554	Merge pull request #306 from vlucas/optionals make selection of which rules to run more clear	2020-02-14 15:19:19 +01:00
Willem Wollebrants	cb2787cfcc	make selection of which rules to run more clear	2020-02-14 15:08:39 +01:00
Willem Wollebrants	2baace22d8	correct documentation for integer strict mode, see #302	2020-02-14 09:44:44 +01:00
Vance Lucas	d0134c33d2	Merge pull request #293 from aecy/master update: more french added	2019-10-24 09:46:33 -05:00
aecyM^	b7c5c09912	update: more french added	2019-09-07 15:12:40 +02:00
Vance Lucas	849d7e7dfb	Add Tidelife support message	2019-08-29 16:21:26 -05:00
Vance Lucas	47af606520	Add Security notice	2019-08-29 16:18:29 -05:00
Willem Wollebrants	a03072bed1	Merge pull request #267 from mangopeaches/required-conditionals Adding requiredWith and requiredWithout conditional rules	2019-08-29 21:49:43 +02:00
Willem Wollebrants	76e44188e2	Merge pull request #284 from tobiashinz/listContains List contains	2019-08-21 12:16:21 +02:00
Willem Wollebrants	89117a92f6	Update .travis.yml	2019-08-15 16:56:21 +02:00
Willem Wollebrants	ec7a20dd50	Update .travis.yml	2019-08-15 16:47:07 +02:00
Willem Wollebrants	f87d5b1905	Merge branch 'master' into listContains	2019-08-15 16:37:50 +02:00
Willem Wollebrants	4cf18608ef	Merge pull request #288 from deveplon/add-allow-null-value-in-subset-method Add some validation to prevent PHP Warning when value in subset is null	2019-08-15 16:36:07 +02:00
Willem Wollebrants	3acb8e23b2	Merge pull request #290 from WillRy/update-es Adding Missing Fields for Spanish language	2019-08-15 16:33:43 +02:00
William R	3f88e776f8	Adding Missing Fields -Added translation to missing fields -New indentation, due to the size of the string 'containsUnique'	2019-07-03 03:55:24 -03:00
Vance Lucas	d3a0a7af11	Merge pull request #289 from WillRy/update-pt-br Adding Missing Fields	2019-07-01 14:13:46 -05:00
William R	01f09244a7	Adding Missing Fields -Added translation to missing fields -New indentation, due to the size of the string 'containsUnique'	2019-06-29 19:56:17 -03:00
Diego Londono	21e9dc1263	Add some validation to prevent PHP Warning when value in subset validation is null	2019-06-27 12:01:05 -03:00
Vance Lucas	a8346868c2	Create FUNDING.yml	2019-06-26 13:13:48 -05:00
Tobias Hinz	c4ea1db371	Usage documentation adjusted	2019-05-09 16:38:39 +02:00
Tobias Hinz	0976fa3a79	Added listContains	2019-05-09 16:34:50 +02:00
Willem Wollebrants	c3b4dac858	Merge pull request #282 from vlucas/iss281 use correct typehint for callable, fix #281	2019-03-21 21:12:22 +01:00
Willem Wollebrants	7705cbc5a0	Merge pull request #280 from apapsch/master Create arrayHasKeys validator.	2019-03-21 21:02:08 +01:00
Willem Wollebrants	dfde682d93	use correct typehint for callable	2019-03-21 21:00:30 +01:00
Aljosha Papsch	2dc2f29f7f	Create arrayHasKeys validator.	2019-03-11 11:46:13 +01:00
Tom Breese	6f125ff666	removing gitignore for netbeans project	2018-10-15 22:42:49 -04:00
Tom Breese	ee4abd9a5f	required-conditionals; fixing count to isset	2018-10-15 22:41:14 -04:00
Tom Breese	757b07f3cd	required-conditionals; adding strict for requiredWithAll and requiredWithoutAll	2018-10-15 22:32:48 -04:00
Tom Breese	e3c6331380	required-conditionals; fixing field typo in readme	2018-10-14 15:32:30 -04:00
Tom Breese	c8c428b3cd	required-conditionals; fixing missing semi colon in readme	2018-10-14 15:30:13 -04:00
Tom Breese	17c2f05168	required-conditionals; adding requiredwith and requiredWithout for conditional requirements	2018-10-14 15:27:37 -04:00