.github/workflows/test.yml

@@ -1,73 +0,0 @@
-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

.gitignore

@@ -3,4 +3,3 @@ composer.phar
 composer.lock
 vendor
 .idea/
-.phpunit.result.cache

.travis.yml

@@ -0,0 +1,31 @@
+#see https://travis-ci.community/t/php-5-4-and-5-5-archives-missing/3723
+dist: trusty
+
+# 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
+  - 7.3
+  - 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

README.md

@@ -6,12 +6,10 @@ 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://github.com/vlucas/valitron/actions/workflows/test.yml/badge.svg)](https://github.com/vlucas/valitron/actions/workflows/test.yml)
+Status](https://travis-ci.org/vlucas/valitron.png?branch=master)](https://travis-ci.org/vlucas/valitron)
 [![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
@@ -127,63 +125,11 @@ 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)
@@ -254,133 +200,7 @@ $v->rules([
 $v->validate();
 ```
 
-## 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();
-```
+Example using alternate syntax.
 
 ## equals fields usage
 The `equals` rule checks if two fields are equals in the data array, and that the second field is not null.
@@ -467,19 +287,24 @@ $v->rules([
 $v->validate();
 ```
 
-*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:
+*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:
 ```php
-$v = new Valitron\Validator(['negative' => '-27', 'positive'=>'27']);
-$v->rule('integer', 'age', true);
-$v->rule('integer', 'height', true);
+$v = new Valitron\Validator(['age' => '-27']);
+$v->rules([
+    'integer' => [
+        ['age', true]
+    ]
+]);
 $v->validate();
 ```
-
-Whereas the following will evaluate to false, as the + for the positive number in this case is redundant:
+Whereas the same for a positive (+) value would evaluate to false, as the + in this case is redundant:
 ```php
-$v = new Valitron\Validator(['negative' => '-27', 'positive'=>'+27']);
-$v->rule('integer', 'age', true);
-$v->rule('integer', 'height', true);
+$v = new Valitron\Validator(['age' => '+27']);
+$v->rules([
+    'integer' => [
+        ['age', true]
+    ]
+]);
 $v->validate();
 ```
 
@@ -1145,7 +970,7 @@ $v = new Valitron\Validator([
         'city' => 'Doe D.C.'
     ]
 ]);
-$v->rule('arrayHasKeys', 'address', ['name', 'street', 'city']);
+$v->rule(['arrayHasKeys', 'address', ['name', 'street', 'city']);
 $v->validate();
 ```
 
@@ -1348,7 +1173,3 @@ before running the tests:
 6. Push to the branch (`git push origin my-new-feature`)
 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.

composer.json

@@ -3,20 +3,20 @@
     "type": "library",
     "description": "Simple, elegant, stand-alone validation library with NO dependencies",
     "keywords": ["validation", "validator", "valid"],
-    "homepage": "https://github.com/vlucas/valitron",
+    "homepage": "http://github.com/vlucas/valitron",
     "license": "BSD-3-Clause",
     "authors": [
         {
             "name": "Vance Lucas",
             "email": "vance@vancelucas.com",
-            "homepage": "https://www.vancelucas.com"
+            "homepage": "http://www.vancelucas.com"
         }
     ],
     "require": {
         "php": ">=5.3.2"
     },
     "require-dev": {
-        "phpunit/phpunit": ">=4.8.35"
+        "phpunit/phpunit": "^4.8.35 || ^5.5 || ^6.5"
     },
     "suggest": {
         "ext-mbstring": "It can support the multiple bytes string length."

lang/en.php

@@ -35,8 +35,6 @@ 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",
 );

lang/fa.php

@@ -1,42 +0,0 @@
-<?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'   => "همه کلیدهای الزامی را ندارد",
-);

lang/fr.php

@@ -1,40 +1,35 @@
 <?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",
-    '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"
+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'"
 );

lang/ja.php

@@ -1,42 +1,35 @@
 <?php
 
 return array(
-    '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'    => "の必要な項目が選択されていません",
+    'required'      => "を入力してください",
+    'equals'        => "は「%s」と同じ内容を入力してください",
+    'different'     => "は「%s」と異なる内容を入力してください",
+    'accepted'      => "に同意してください",
+    'numeric'       => "は数値を入力してください",
+    'integer'       => "は半角数字で入力してください",
+    'length'        => "は%d文字で入力してください",
+    'min'           => "には%sより大きな値を入力してください",
+    'max'           => "には%sより小さな値を入力してください",
+    'listContains'  => "には選択できない値が含まれています",
+    '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」のインスタンスではありません",
 );

lang/sl.php

@@ -1,42 +0,0 @@
-<?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",
-);

lang/sv.php

@@ -13,23 +13,23 @@ return array(
 	'listContains'  => "innehåller ogiltigt värde",
 	'in'            => "innehåller ogiltigt värde",
 	'notIn'         => "innehåller ogiltigt värde",
-	'ip'            => "är inte en giltig IP-adress",
-	'email'         => "är inte en giltig e-postadress",
-	'url'           => "är inte en giltig URL",
+	'ip'            => "är inte en giltlig IP-adress",
+	'email'         => "är inte en giltlig e-postadress",
+	'url'           => "är inte en giltlig URL",
 	'urlActive'     => "måste vara ett aktivt domännamn",
-	'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",
+	'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",
 	'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 ett giltigt kreditkortsnummer",
+	'creditCard'    => "måste vara et gyldig kredittkortnummer",
 	'lengthMin'     => "måste vara minst %d tecken långt",
-	'lengthMax'     => "får inte överstiga %d tecken",
+	'lengthMax'     => "får itne överstiga %d tecken",
 	'instanceOf'    => "måste vara en instans av '%s'"
 );

lang/tr.php

@@ -29,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 karakterden fazla içermeli",
+    "lengthMin"     => "%d katakterden fazla içermeli",
     "lengthMax"     => "%d karakterden az içermeli",
     "instanceOf"    => "bunun bir örneği olmalı '%s'"
 );

lang/zh-cn.php

@@ -7,7 +7,7 @@ return array(
     'accepted'      => "必须接受",
     'numeric'       => "只能是数字",
     'integer'       => "只能是整数",
-    'length'        => "长度必须等于 %d",
+    'length'        => "长度必须大于 %d",
     'min'           => "必须大于 %s",
     'max'           => "必须小于 %s",
     'listContains'  => "无效的值",
@@ -30,11 +30,5 @@ return array(
     'lengthBetween' => "长度只能介于 %d 和 %d 之间",
     'creditCard'    => "信用卡号码不正确",
     'lengthMin'     => "长度必须大于 %d",
-    'lengthMax'     => "长度必须小于 %d",
-    'instanceOf'     => "必须是 '%s' 的实例",
-    'containsUnique' => "必须仅包含唯一的元素",
-    'requiredWith'   => "是必须的",
-    'requiredWithout' => "是必须的",
-    'subset'         => "包含不在列表中的项目",
-    'arrayHasKeys'   => "不包含所有必需的键",
+    'lengthMax'     => "长度必须小于 %d"
 );

lang/zh-tw.php

@@ -1,40 +1,29 @@
 <?php
 
 return array(
-  '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'   => "不包含所有必需的鍵",
+    '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"
 );

phpunit.xml

@@ -7,6 +7,7 @@
          convertWarningsToExceptions="true"
          processIsolation="false"
          stopOnFailure="false"
+         syntaxCheck="false"
          bootstrap="tests/bootstrap.php"
 >
   <testsuites>
@@ -14,4 +15,12 @@
       <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>

src/Valitron/Validator.php

@@ -83,11 +83,6 @@ class Validator
      */
     protected $stop_on_first_fail = false;
 
-    /**
-     * @var bool
-     */
-    protected $prepend_labels = true;
-
     /**
      * Setup validation
      *
@@ -149,14 +144,6 @@ 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
      *
@@ -172,7 +159,9 @@ class Validator
             return $find[1];
         }
 
-        if (is_null($value) || (is_string($value) && trim($value) === '')) {
+        if (is_null($value)) {
+            return false;
+        } elseif (is_string($value) && trim($value) === '') {
             return false;
         }
 
@@ -420,13 +409,9 @@ class Validator
      */
     protected function validateIn($field, $value, $params)
     {
-        $forceAsAssociative = false;
-        if (isset($params[2])) {
-            $forceAsAssociative = (bool) $params[2];
-        }
-
-        if ($forceAsAssociative || $this->isAssociativeArray($params[0])) {
-           $params[0] = array_keys($params[0]);
+        $isAssoc = array_values($params[0]) !== $params[0];
+        if ($isAssoc) {
+            $params[0] = array_keys($params[0]);
         }
 
         $strict = false;
@@ -447,12 +432,8 @@ class Validator
      */
     protected function validateListContains($field, $value, $params)
     {
-        $forceAsAssociative = false;
-        if (isset($params[2])) {
-            $forceAsAssociative = (bool) $params[2];
-        }
-
-        if ($forceAsAssociative || $this->isAssociativeArray($value)) {
+        $isAssoc = array_values($value) !== $value;
+        if ($isAssoc) {
             $value = array_keys($value);
         }
 
@@ -630,17 +611,12 @@ 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, 'MX');
+            return checkdnsrr($domain, 'ANY');
         }
 
         return false;
@@ -655,10 +631,6 @@ 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;
@@ -677,10 +649,6 @@ 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);
@@ -909,9 +877,11 @@ 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)) && preg_match($cardRegex[$card], $value) === 1) {
+                        if (in_array($card, array_keys($cardRegex))) {
                             // if the card is valid, we want to stop looping
-                            return true;
+                            if (preg_match($cardRegex[$card], $value) === 1) {
+                                return true;
+                            }
                         }
                     }
                 } else {
@@ -950,94 +920,6 @@ 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
      *
@@ -1119,8 +1001,10 @@ class Validator
                 }
             }
             // Use custom label instead of field name if set
-            if (is_string($params[0]) && isset($this->_labels[$param])) {
-                $param = $this->_labels[$param];
+            if (is_string($params[0])) {
+                if (isset($this->_labels[$param])) {
+                    $param = $this->_labels[$param];
+                }
             }
             $values[] = $param;
         }
@@ -1195,27 +1079,6 @@ 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
      *
@@ -1228,7 +1091,14 @@ class Validator
             foreach ($v['fields'] as $field) {
                 list($values, $multiple) = $this->getPart($this->_fields, explode('.', $field), false);
 
-                if (! $this->validationMustBeExcecuted($v, $field, $values, $multiple)){
+                // 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))
+                ) {
                     continue;
                 }
 
@@ -1306,8 +1176,10 @@ class Validator
     protected function hasRule($name, $field)
     {
         foreach ($this->_validations as $validation) {
-            if ($validation['rule'] == $name && in_array($field, $validation['fields'])) {
-                return true;
+            if ($validation['rule'] == $name) {
+                if (in_array($field, $validation['fields'])) {
+                    return true;
+                }
             }
         }
 
@@ -1497,9 +1369,7 @@ class Validator
                 }
             }
         } else {
-            $message = $this->prepend_labels
-                ? str_replace('{field}', ucwords(str_replace('_', ' ', $field)), $message)
-                : str_replace('{field} ', '', $message);
+            $message = str_replace('{field}', ucwords(str_replace('_', ' ', $field)), $message);
         }
 
         return $message;
@@ -1586,9 +1456,4 @@ 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;
-    }
 }

tests/Valitron/BaseTestCase.php

@@ -4,8 +4,10 @@ use PHPUnit\Framework\TestCase;
 
 class BaseTestCase extends TestCase
 {
+	public function setUp()
+	{
+	}
 
-/*
 	public function tearDown()
 	{
 		$this->resetProperty('_lang');
@@ -21,5 +23,4 @@ class BaseTestCase extends TestCase
 		$prop->setValue($value);
 		$prop->setAccessible(false);
 	}
-*/
 }

tests/Valitron/ErrorMessagesTest.php

@@ -12,19 +12,6 @@ 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));

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,15 +42,13 @@ 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());
-        }
 	}
 
 

tests/Valitron/StaticVsInstanceTest.php

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

tests/Valitron/ValidateTest.php

@@ -980,7 +980,6 @@ class ValidateTest extends BaseTestCase
                 array('color', array('blue', 'green', 'red', 'yellow'))
             )
         ));
-        $this->assertFalse($v->validate());
     }
 
     public function testAsciiValid()
@@ -2259,338 +2258,6 @@ 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
      */
@@ -2920,46 +2587,6 @@ class ValidateTest extends BaseTestCase
         $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)