diff --git a/README.md b/README.md
index 337412b..9eb0f82 100644
--- a/README.md
+++ b/README.md
@@ -99,6 +99,19 @@ if($v->validate()) {
 }
 ```
 
+You can also access nested values using dot notation:
+
+```php
+$v = new Valitron\Validator(array('user' => array('first_name' => 'Steve', 'last_name' => 'Smith', 'username' => 'Batman123')));
+$v->rule('alpha', 'user.first_name')->rule('alpha', 'user.last_name')->rule('alphaNum', 'user.username');
+if($v->validate()) {
+    echo "Yay! We're all good!";
+} else {
+    // Errors
+    print_r($v->errors());
+}
+```
+
 Setting language and language dir globally:
 
 ```php
@@ -161,7 +174,7 @@ extension for greater accuracy and reliability. The extension is not required
 for Valitron to work, but Valitron will use it if available, and it is highly
 recommended.
 
-## Required fields
+## required fields usage
 the `required` rule checks if a field exists in the data array, and is not null or an empty string.
 ```php
 $v->rule('required', 'field_name');
@@ -171,6 +184,664 @@ Using an extra parameter, you can make this rule more flexible, and only check i
 ```php
 $v->rule('required', 'field_name', true);
 ```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'spiderman', 'password' => 'Gr33nG0Blin', 'required_but_null' => null]);
+$v->rules([
+    'required' => [
+        ['username'],
+        ['password'],
+        ['required_but_null', true] // boolean flag allows empty value so long as the field name is set on the data array
+    ]
+]);
+$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.
+```php
+$v->rule('equals', 'password', 'confirmPassword');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['password' => 'youshouldnotseethis', 'confirmPassword' => 'youshouldnotseethis']);
+$v->rules([
+    'equals' => [
+        ['password', 'confirmPassword']
+    ]
+]);
+$v->validate();
+```
+
+## different fields usage
+The `different` rule checks if two fields are not the same, or different, in the data array and that the second field is not null.
+```php
+$v->rule('different', 'username', 'password');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'spiderman', 'password' => 'Gr33nG0Blin']);
+$v->rules([
+    'different' => [
+        ['username', 'password']
+    ]
+]);
+$v->validate();
+```
+
+## accepted fields usage
+The `accepted` rule checks if the field is either 'yes', 'on', 1, or true.
+```php
+$v->rule('accepted', 'remember_me');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['remember_me' => true]);
+$v->rules([
+    'accepted' => [
+        ['remember_me']
+    ]
+]);
+$v->validate();
+```
+
+## numeric fields usage
+The `numeric` rule checks if the field is number. This is analogous to php's is_numeric() function.
+```php
+$v->rule('numeric', 'amount');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['amount' => 3.14]);
+$v->rules([
+    'numeric' => [
+        ['amount']
+    ]
+]);
+$v->validate();
+```
+
+## integer fields usage
+The `integer` rule checks if the field is an integer number.
+```php
+$v->rule('integer', 'age');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['age' => '27']);
+$v->rules([
+    'integer' => [
+        ['age']
+    ]
+]);
+$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:
+```php
+$v = new Valitron\Validator(['age' => '-27']);
+$v->rules([
+    'integer' => [
+        ['age', true]
+    ]
+]);
+$v->validate();
+```
+Whereas the same for a positive (+) value would evaluate to false, as the + in this case is redundant:
+```php
+$v = new Valitron\Validator(['age' => '+27']);
+$v->rules([
+    'integer' => [
+        ['age', true]
+    ]
+]);
+$v->validate();
+```
+
+## boolean fields usage
+The `boolean` rule checks if the field is a boolean. This is analogous to php's is_bool() function.
+```php
+$v->rule('boolean', 'remember_me');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['remember_me' => true]);
+$v->rules([
+    'boolean' => [
+        ['remember_me']
+    ]
+]);
+$v->validate();
+```
+
+## array fields usage
+The `array` rule checks if the field is an array. This is analogous to php's is_array() function.
+```php
+$v->rule('array', 'user_notifications');
+```
+
+Alternate Syntax.
+```php
+$v = new Valitron\Validator(['user_notifications' => ['bulletin_notifications' => true, 'marketing_notifications' => false, 'message_notification' => true]]);
+$v->rules([
+    'array' => [
+        ['user_notifications']
+    ]
+]);
+$v->validate();
+```
+
+## length fields usage
+The `length` rule checks if the field is exactly a given length and that the field is a valid string.
+```php
+$v->rule('length', 'username', 10);
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'bobburgers']);
+$v->rules([
+    'length' => [
+        ['username', 10]
+    ]
+]);
+$v->validate();
+```
+
+## lengthBetween fields usage
+The `lengthBetween` rule checks if the field is between a given length tange and that the field is a valid string.
+```php
+$v->rule('lengthBetween', 'username', 1, 10);
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'bobburgers']);
+$v->rules([
+    'lengthBetween' => [
+        ['username', 1, 10]
+    ]
+]);
+$v->validate();
+```
+
+## lengthMin fields usage
+The `lengthMin` rule checks if the field is at least a given length and that the field is a valid string.
+```php
+$v->rule('lengthMin', 'username', 5);
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'martha']);
+$v->rules([
+    'lengthMin' => [
+        ['username', 5]
+    ]
+]);
+$v->validate();
+```
+
+## lengthMax fields usage
+The `lengthMax` rule checks if the field is at most a given length and that the field is a valid string.
+```php
+$v->rule('lengthMax', 'username', 10);
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'bruins91']);
+$v->rules([
+    'lengthMax' => [
+        ['username', 10]
+    ]
+]);
+$v->validate();
+```
+
+## min fields usage
+The `min` rule checks if the field is at least a given value and that the provided value is numeric.
+```php
+$v->rule('min', 'age', 18);
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['age' => 28]);
+$v->rules([
+    'min' => [
+        ['age', 18]
+    ]
+]);
+$v->validate();
+```
+
+## max fields usage
+The `max` rule checks if the field is at most a given value and that the provided value is numeric.
+```php
+$v->rule('max', 'age', 12);
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['age' => 10]);
+$v->rules([
+    'max' => [
+        ['age', 12]
+    ]
+]);
+$v->validate();
+```
+
+## in fields usage
+The `in` rule checks that the field is present in a given array of values.
+```php
+$v->rule('in', 'color', ['blue', 'green', 'red', 'purple']);
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['color' => 'purple']);
+$v->rules([
+    'in' => [
+        ['color', ['blue', 'green', 'red', 'purple']]
+    ]
+]);
+$v->validate();
+```
+
+## notIn fields usage
+The `notIn` rule checks that the field is NOT present in a given array of values.
+```php
+$v->rule('notIn', 'color', ['blue', 'green', 'red', 'yellow']);
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['color' => 'purple']);
+$v->rules([
+    'notIn' => [
+        ['color', ['blue', 'green', 'red', 'yellow']]
+    ]
+]);
+$v->validate();
+```
+
+## ip fields usage
+The `ip` rule checks that the field is a valid ip address. This includes IPv4, IPv6, private, and reserved ranges.
+```php
+$v->rule('ip', 'user_ip');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['user_ip' => '127.0.0.1']);
+$v->rules([
+    'ip' => [
+        ['user_ip']
+    ]
+]);
+$v->validate();
+```
+
+## ipv4 fields usage
+The `ipv4` rule checks that the field is a valid IPv4 address.
+```php
+$v->rule('ipv4', 'user_ip');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['user_ip' => '127.0.0.1']);
+$v->rules([
+    'ipv4' => [
+        ['user_ip']
+    ]
+]);
+$v->validate();
+```
+
+## ipv6 fields usage
+The `ipv6` rule checks that the field is a valid IPv6 address.
+```php
+$v->rule('ipv6', 'user_ip');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['user_ip' => '0:0:0:0:0:0:0:1']);
+$v->rules([
+    'ipv6' => [
+        ['user_ip']
+    ]
+]);
+$v->validate();
+```
+
+## email fields usage
+The `email` rule checks that the field is a valid email address.
+```php
+$v->rule('email', 'user_email');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['user_email' => 'someone@example.com']);
+$v->rules([
+    'email' => [
+        ['user_email']
+    ]
+]);
+$v->validate();
+```
+
+## emailDNS fields usage
+The `emailDNS` rule validates the field is a valid email address with an active DNS record or any type.
+```php
+$v->rule('emailDNS', 'user_email');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['user_email' => 'some_fake_email_address@gmail.com']);
+$v->rules([
+    'emailDNS' => [
+        ['user_email']
+    ]
+]);
+$v->validate();
+```
+
+## url fields usage
+The `url` rule checks the field is a valid url.
+```php
+$v->rule('url', 'website');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['website' => 'https://example.com/contact']);
+$v->rules([
+    'url' => [
+        ['website']
+    ]
+]);
+$v->validate();
+```
+
+## urlActive fields usage
+The `urlActive` rule checks the field is a valid url with an active A, AAAA, or CNAME record.
+```php
+$v->rule('urlActive', 'website');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['website' => 'https://example.com/contact']);
+$v->rules([
+    'urlActive' => [
+        ['website']
+    ]
+]);
+$v->validate();
+```
+
+## alpha fields usage
+The `alpha` rule checks the field is alphabetic characters only.
+```php
+$v->rule('alpha', 'username');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'batman']);
+$v->rules([
+    'alpha' => [
+        ['username']
+    ]
+]);
+$v->validate();
+```
+
+## alphaNum fields usage
+The `alphaNum` rule checks the field contains only alphabetic or numeric characters.
+```php
+$v->rule('alphaNum', 'username');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'batman123']);
+$v->rules([
+    'alphaNum' => [
+        ['username']
+    ]
+]);
+$v->validate();
+```
+
+## ascii fields usage
+The `ascii` rule checks the field contains only characters in the ascii character set.
+```php
+$v->rule('ascii', 'username');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'batman123']);
+$v->rules([
+    'ascii' => [
+        ['username']
+    ]
+]);
+$v->validate();
+```
+
+## slug fields usage
+The `slug` rule checks that the field only contains URL slug characters (a-z, 0-9, -, _).
+```php
+$v->rule('slug', 'username');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'L337-H4ckZ0rz_123']);
+$v->rules([
+    'slug' => [
+        ['username']
+    ]
+]);
+$v->validate();
+```
+
+## regex fields usage
+The `regex` rule ensures the field matches a given regex pattern.
+(This regex checks the string is alpha numeric between 5-10 characters).
+```php
+$v->rule('regex', 'username', '/^[a-zA-Z0-9]{5,10}$/');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'Batman123']);
+$v->rules([
+    'regex' => [
+        ['username', '/^[a-zA-Z0-9]{5,10}$/']
+    ]
+]);
+$v->validate();
+```
+
+## date fields usage
+The `date` rule checks if the supplied field is a valid \DateTime object or if the string can be converted to a unix timestamp via strtotime().
+```php
+$v->rule('date', 'created_at');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['created_at' => '2018-10-13']);
+$v->rules([
+    'date' => [
+        ['created_at']
+    ]
+]);
+$v->validate();
+```
+
+## dateFormat fields usage
+The `dateFormat` rule checks that the supplied field is a valid date in a specified date format.
+```php
+$v->rule('dateFormat', 'created_at', 'Y-m-d');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['created_at' => '2018-10-13']);
+$v->rules([
+    'dateFormat' => [
+        ['created_at', 'Y-m-d']
+    ]
+]);
+$v->validate();
+```
+
+## dateBefore fields usage
+The `dateBefore` rule checks that the supplied field is a valid date before a specified date.
+```php
+$v->rule('dateBefore', 'created_at', '2018-10-13');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['created_at' => '2018-09-01']);
+$v->rules([
+    'dateBefore' => [
+        ['created_at', '2018-10-13']
+    ]
+]);
+$v->validate();
+```
+
+## dateAfter fields usage
+The `dateAfter` rule checks that the supplied field is a valid date after a specified date.
+```php
+$v->rule('dateAfter', 'created_at', '2018-10-13');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['created_at' => '2018-09-01']);
+$v->rules([
+    'dateAfter' => [
+        ['created_at', '2018-01-01']
+    ]
+]);
+$v->validate();
+```
+
+## contains fields usage
+The `contains` rule checks that a given string exists within the field and checks that the field and the search value are both valid strings.
+```php
+$v->rule('contains', 'username', 'man');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['username' => 'Batman123']);
+$v->rules([
+    'contains' => [
+        ['username', 'man']
+    ]
+]);
+$v->validate();
+```
+
+*Note* You can use the optional strict flag to ensure a case-sensitive match.
+The following example will return true:
+```php
+$v = new Valitron\Validator(['username' => 'Batman123']);
+$v->rules([
+    'contains' => [
+        ['username', 'man']
+    ]
+]);
+$v->validate();
+```
+Whereas, this would return false, as the M in the search string is not uppercase in the provided value:
+```php
+$v = new Valitron\Validator(['username' => 'Batman123']);
+$v->rules([
+    'contains' => [
+        ['username', 'Man', true]
+    ]
+]);
+$v->validate();
+```
+
+## subset fields usage
+The `subset` rule checks that the field is either a scalar or array field and that all of it's values are contained within a given set of values.
+```php
+$v->rule('subset', 'colors', ['green', 'blue', 'orange']);
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['colors' => ['green', 'blue']]);
+$v->rules([
+    'subset' => [
+        ['colors', ['orange', 'green', 'blue', 'red']]
+    ]
+]);
+$v->validate();
+```
+This example would return false, as the provided color, purple, does not exist in the array of accepted values we're providing.
+```php
+$v = new Valitron\Validator(['colors' => ['purple', 'blue']]);
+$v->rules([
+    'subset' => [
+        ['colors', ['orange', 'green', 'blue', 'red']]
+    ]
+]);
+$v->validate();
+```
+
+## containsUnique fields usage
+The `containsUnique` rule checks that the provided field is an array and that all values contained within are unique, i.e. no duplicate values in the array.
+```php
+$v->rule('containsUnique', 'colors');
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['colors' => ['purple', 'blue']]);
+$v->rules([
+    'containsUnique' => [
+        ['colors']
+    ]
+]);
+$v->validate();
+```
+This example would return false, as the values in the provided array are duplicates.
+```php
+$v = new Valitron\Validator(['colors' => ['purple', 'purple']]);
+$v->rules([
+    'containsUnique' => [
+        ['colors']
+    ]
+]);
+$v->validate();
+```
+
 ## Credit Card Validation usage
 
 Credit card validation currently allows you to validate a Visa `visa`,
@@ -204,6 +875,68 @@ $v->rule('creditCard', 'credit_card', $cardType, ['visa', 'mastercard']);
 $v->validate(); // false
 ```
 
+## instanceOf fields usage
+The `instanceOf` rule checks that the field is an instance of a given class.
+```php
+$v->rule('instanceOf', 'date', \DateTime);
+```
+
+Alternate syntax.
+```php
+$v = new Valitron\Validator(['date' => new \DateTime()]);
+$v->rules([
+    'instanceOf' => [
+        ['date', 'DateTime']
+    ]
+]);
+$v->validate();
+```
+*Note* You can also compare the value against a given object as opposed to the string class name.
+This example would also return true:
+```php
+$v = new Valitron\Validator(['date' => new \DateTime()]);
+$existingDateObject = new \DateTime();
+$v->rules([
+    'instanceOf' => [
+        ['date', $existingDateObject]
+    ]
+]);
+$v->validate();
+```
+
+## optional fields usage
+The `optional` rule ensures that if the field is present in the data set that it passes all validation rules.
+```php
+$v->rule('optional', 'username');
+```
+
+Alternate syntax.
+This example would return true either when the 'username' field is not present or in the case where the username is only alphabetic characters.
+```php
+$v = new Valitron\Validator(['username' => 'batman']);
+$v->rules([
+    'alpha' => [
+        ['username']
+    ],
+    'optional' => [
+        ['username']
+    ]
+]);
+$v->validate();
+```
+This example would return false, as although the field is optional, since it is provided it must pass all the validation rules, which in this case it does not.
+```php
+$v = new Valitron\Validator(['username' => 'batman123']);
+$v->rules([
+    'alpha' => [
+        ['username']
+    ],
+    'optional' => [
+        ['username']
+    ]
+]);
+$v->validate();
+```
 
 ## Adding Custom Validation Rules
 
@@ -240,6 +973,14 @@ This rule will take the same parameters as
 `Validator::addRule` but it has to be called on a `Validator`
 instance.
 
+## Chaining rules
+
+You can chain multiple rules together using the following syntax.
+```php
+$v = new Valitron\Validator(['email_address' => 'test@test.com']);
+$v->rule('required', 'email_address')->rule('email', 'email_address');
+$v->validate();
+```
 
 ## Alternate syntax for adding rules
 
diff --git a/tests/Valitron/ValidateTest.php b/tests/Valitron/ValidateTest.php
index ba59117..169c0e6 100644
--- a/tests/Valitron/ValidateTest.php
+++ b/tests/Valitron/ValidateTest.php
@@ -51,6 +51,19 @@ public function testRequiredValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testRequiredValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'spiderman', 'password' => 'Gr33nG0Blin', 'required_but_null' => null));
+        $v->rules(array(
+            'required' => array(
+                array('username'),
+                array('password'),
+                array('required_but_null', true) // boolean flag allows empty value so long as the field name is set on the data array
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testRequiredNonExistentField()
     {
         $v = new Validator(array('name' => 'Chester Tester'));
@@ -58,6 +71,18 @@ public function testRequiredNonExistentField()
         $this->assertFalse($v->validate());
     }
 
+    public function testRequiredNonExistentFieldAltSyntax()
+    {
+        $v = new Valitron\Validator(array('boozername' => 'spiderman', 'notPassword' => 'Gr33nG0Blin'));
+        $v->rules(array(
+            'required' => array(
+                array('username'),
+                array('password')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testEqualsValid()
     {
         $v = new Validator(array('foo' => 'bar', 'bar' => 'bar'));
@@ -65,6 +90,17 @@ public function testEqualsValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testEqualsValidAltSyntax()
+    {
+        $v = new Validator(array('password' => 'youshouldnotseethis', 'confirmPassword' => 'youshouldnotseethis'));
+        $v->rules(array(
+            'equals' => array(
+                array('password', 'confirmPassword')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testEqualsInvalid()
     {
         $v = new Validator(array('foo' => 'foo', 'bar' => 'bar'));
@@ -72,6 +108,17 @@ public function testEqualsInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testEqualsInvalidAltSyntax()
+    {
+        $v = new Validator(array('password' => 'youshouldnotseethis', 'confirmPassword' => 'differentpassword'));
+        $v->rules(array(
+            'equals' => array(
+                array('password', 'confirmPassword')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testEqualsBothNull()
     {
         $v = new Validator(array('foo' => null, 'bar' => null));
@@ -109,6 +156,17 @@ public function testDifferentValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testDifferentValidAltSyntax()
+    {
+        $v = new Validator(array('username' => 'test', 'password' => 'test123'));
+        $v->rules(array(
+            'different' => array(
+                array('username', 'password')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testDifferentInvalid()
     {
         $v = new Validator(array('foo' => 'baz', 'bar' => 'baz'));
@@ -116,6 +174,17 @@ public function testDifferentInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testDifferentInvalidAltSyntax()
+    {
+        $v = new Validator(array('username' => 'test', 'password' => 'test'));
+        $v->rules(array(
+            'different' => array(
+                array('username', 'password')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testDifferentBothNull()
     {
         $v = new Validator(array('foo' => null, 'bar' => null));
@@ -153,6 +222,17 @@ public function testAcceptedValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testAcceptedValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('remember_me' => true));
+        $v->rules(array(
+            'accepted' => array(
+                array('remember_me')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testAcceptedInvalid()
     {
         $v = new Validator(array('agree' => 'no'));
@@ -160,6 +240,17 @@ public function testAcceptedInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testAcceptedInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('remember_me' => false));
+        $v->rules(array(
+            'accepted' => array(
+                array('remember_me')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testAcceptedNotSet()
     {
         $v = new Validator();
@@ -174,6 +265,17 @@ public function testNumericValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testNumericValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('amount' => 3.14));
+        $v->rules(array(
+            'numeric' => array(
+                array('amount')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testNumericInvalid()
     {
         $v = new Validator(array('num' => 'nope'));
@@ -181,6 +283,17 @@ public function testNumericInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testNumericInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('amount' => 'banana'));
+        $v->rules(array(
+            'numeric' => array(
+                array('amount')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testIntegerValid()
     {
         $v = new Validator(array('num' => '41243'));
@@ -192,6 +305,17 @@ public function testIntegerValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testIntegerValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('age' => 27));
+        $v->rules(array(
+            'integer' => array(
+                array('age', true)
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testIntegerStrict()
     {
 
@@ -255,6 +379,17 @@ public function testIntegerInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testIntegerInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('age' => 3.14));
+        $v->rules(array(
+            'integer' => array(
+                array('age')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testLengthValid()
     {
         $v = new Validator(array('str' => 'happy'));
@@ -262,6 +397,17 @@ public function testLengthValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testLengthValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'bobburgers'));
+        $v->rules(array(
+            'length' => array(
+                array('username', 10)
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testLengthInvalid()
     {
         $v = new Validator(array('str' => 'sad'));
@@ -277,6 +423,17 @@ public function testLengthInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testLengthInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'hi'));
+        $v->rules(array(
+            'length' => array(
+                array('username', 10)
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testLengthBetweenValid()
     {
         $v = new Validator(array('str' => 'happy'));
@@ -284,6 +441,17 @@ public function testLengthBetweenValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testLengthBetweenValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'bobburgers'));
+        $v->rules(array(
+            'lengthBetween' => array(
+                array('username', 1, 10)
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testLengthBetweenInvalid()
     {
         $v = new Validator(array('str' => 'sad'));
@@ -299,12 +467,34 @@ public function testLengthBetweenInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testLengthBetweenInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'hi'));
+        $v->rules(array(
+            'lengthBetween' => array(
+                array('username', 3, 10)
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testLengthMinValid()
     {
         $v = new Validator(array('str' => 'happy'));
         $v->rule('lengthMin', 'str', 4);
         $this->assertTrue($v->validate());
     }
+    
+    public function testLengthMinValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'martha'));
+        $v->rules(array(
+            'lengthMin' => array(
+                array('username', 5)
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
 
     public function testLengthMinInvalid()
     {
@@ -313,6 +503,17 @@ public function testLengthMinInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testLengthMinInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'abc'));
+        $v->rules(array(
+            'lengthMin' => array(
+                array('username', 5)
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testLengthMaxValid()
     {
         $v = new Validator(array('str' => 'sad'));
@@ -320,6 +521,17 @@ public function testLengthMaxValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testLengthMaxValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'bruins91'));
+        $v->rules(array(
+            'lengthMax' => array(
+                array('username', 10)
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testLengthMaxInvalid()
     {
         $v = new Validator(array('str' => 'sad'));
@@ -327,6 +539,17 @@ public function testLengthMaxInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testLengthMaxInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'bruins91'));
+        $v->rules(array(
+            'lengthMax' => array(
+                array('username', 3)
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testMinValid()
     {
         $v = new Validator(array('num' => 5));
@@ -338,6 +561,17 @@ public function testMinValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testMinValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('age' => 28));
+        $v->rules(array(
+            'min' => array(
+                array('age', 18)
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testMinValidFloat()
     {
         if (!function_exists('bccomp')) {
@@ -368,6 +602,17 @@ public function testMinInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testMinInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('age' => 16));
+        $v->rules(array(
+            'min' => array(
+                array('age', 18)
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testMinInvalidFloat()
     {
         $v = new Validator(array('num' => 0.5));
@@ -386,6 +631,17 @@ public function testMaxValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testMaxValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('age' => 10));
+        $v->rules(array(
+            'max' => array(
+                array('age', 12)
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testMaxValidFloat()
     {
         if (!function_exists('bccomp')) {
@@ -416,6 +672,17 @@ public function testMaxInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testMaxInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('age' => 29));
+        $v->rules(array(
+            'max' => array(
+                array('age', 12)
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testMaxInvalidFloat()
     {
         $v = new Validator(array('num' => 0.9));
@@ -466,6 +733,28 @@ public function testInValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testInValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('color' => 'purple'));
+        $v->rules(array(
+            'in' => array(
+                array('color', array('blue', 'green', 'red', 'purple'))
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testInInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('color' => 'orange'));
+        $v->rules(array(
+            'in' => array(
+                array('color', array('blue', 'green', 'red', 'purple'))
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testInValidAssociativeArray()
     {
         $v = new Validator(array('color' => 'green'));
@@ -491,6 +780,17 @@ public function testArrayValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testArrayValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('user_notifications' => array('bulletin_notifications' => true, 'marketing_notifications' => false, 'message_notification' => true)));
+        $v->rules(array(
+            'array' => array(
+                array('user_notifications')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testAssocArrayValid()
     {
         $v = new Validator(array('settings' => array('color' => 'yellow')));
@@ -498,6 +798,17 @@ public function testAssocArrayValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testArrayInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('user_notifications' => 'string'));
+        $v->rules(array(
+            'array' => array(
+                array('user_notifications')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testArrayInvalid()
     {
         $v = new Validator(array('colors' => 'yellow'));
@@ -614,6 +925,17 @@ public function testNotInValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testNotInValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('color' => 'purple'));
+        $v->rules(array(
+            'notIn' => array(
+                array('color', array('blue', 'green', 'red', 'yellow'))
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testNotInInvalid()
     {
         $v = new Validator(array('color' => 'blue'));
@@ -621,6 +943,16 @@ public function testNotInInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testNotInInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('color' => 'yellow'));
+        $v->rules(array(
+            'notIn' => array(
+                array('color', array('blue', 'green', 'red', 'yellow'))
+            )
+        ));
+    }
+
     public function testAsciiValid()
     {
         $v = new Validator(array('text' => '12345 abcde'));
@@ -628,6 +960,17 @@ public function testAsciiValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testAsciiValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'batman123'));
+        $v->rules(array(
+            'ascii' => array(
+                array('username')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testAsciiInvalid()
     {
         $v = new Validator(array('text' => '12345 abcdé'));
@@ -635,6 +978,17 @@ public function testAsciiInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testAsciiInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => '12345 abcdé'));
+        $v->rules(array(
+            'ascii' => array(
+                array('username')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testIpValid()
     {
         $v = new Validator(array('ip' => '127.0.0.1'));
@@ -642,6 +996,17 @@ public function testIpValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testIpValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('user_ip' => '127.0.0.1'));
+        $v->rules(array(
+            'ip' => array(
+                array('user_ip')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testIpInvalid()
     {
         $v = new Validator(array('ip' => 'buy viagra now!'));
@@ -649,6 +1014,17 @@ public function testIpInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testIpInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('user_ip' => '127.0.0.1.345'));
+        $v->rules(array(
+            'ip' => array(
+                array('user_ip')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testIpv4Valid()
     {
         $v = new Validator(array('ip' => '127.0.0.1'));
@@ -656,6 +1032,17 @@ public function testIpv4Valid()
         $this->assertTrue($v->validate());
     }
 
+    public function testIpv4ValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('user_ip' => '127.0.0.1'));
+        $v->rules(array(
+            'ipv4' => array(
+                array('user_ip')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testIpv4Invalid()
     {
         $v = new Validator(array('ip' => 'FE80::0202:B3FF:FE1E:8329'));
@@ -663,6 +1050,17 @@ public function testIpv4Invalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testIpv4InvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('user_ip' => '127.0.0.1.234'));
+        $v->rules(array(
+            'ipv4' => array(
+                array('user_ip')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testIpv6Valid()
     {
         $v = new Validator(array('ip' => 'FE80::0202:B3FF:FE1E:8329'));
@@ -670,6 +1068,17 @@ public function testIpv6Valid()
         $this->assertTrue($v->validate());
     }
 
+    public function testIpv6ValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('user_ipv6' => '0:0:0:0:0:0:0:1'));
+        $v->rules(array(
+            'ipv6' => array(
+                array('user_ipv6')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testIpv6Invalid()
     {
         $v = new Validator(array('ip' => '127.0.0.1'));
@@ -677,6 +1086,17 @@ public function testIpv6Invalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testIpv6InvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('user_ipv6' => '0:0:0:0:0:0:0:1:3:4:5'));
+        $v->rules(array(
+            'ipv6' => array(
+                array('user_ipv6')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testEmailValid()
     {
         $v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.com'));
@@ -684,10 +1104,32 @@ public function testEmailValid()
         $this->assertTrue($v->validate());
     }
 
-    public function testEmailInvalid()
+    public function testEmailValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('user_email' => 'someone@example.com'));
+        $v->rules(array(
+            'email' => array(
+                array('user_email')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
+    public function testEmailInvalid()
+    {
+        $v = new Validator(array('name' => 'Chester Tester', 'email' => 'chestertesterman'));
+        $v->rule('email', 'email');
+        $this->assertFalse($v->validate());
+    }
+
+    public function testEmailInvalidAltSyntax()
     {
-        $v = new Validator(array('name' => 'Chester Tester', 'email' => 'chestertesterman'));
-        $v->rule('email', 'email');
+        $v = new Valitron\Validator(array('user_email' => 'example.com'));
+        $v->rules(array(
+            'email' => array(
+                array('user_email')
+            )
+        ));
         $this->assertFalse($v->validate());
     }
 
@@ -698,6 +1140,17 @@ public function testEmailDnsValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testEmailDnsValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('user_email' => 'some_fake_email_address@gmail.com'));
+        $v->rules(array(
+            'emailDNS' => array(
+                array('user_email')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testEmailDnsInvalid()
     {
         $v = new Validator(array('name' => 'Chester Tester', 'email' => 'chester@tester.zyx'));
@@ -705,6 +1158,17 @@ public function testEmailDnsInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testEmailDnsInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('user_email' => 'some_fake_email_address@gmail.zyx'));
+        $v->rules(array(
+            'emailDNS' => array(
+                array('user_email')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testUrlValid()
     {
         $v = new Validator(array('website' => 'http://google.com'));
@@ -712,6 +1176,17 @@ public function testUrlValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testUrlValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('website' => 'https://example.com/contact'));
+        $v->rules(array(
+            'url' => array(
+                array('website')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testUrlInvalid()
     {
         $v = new Validator(array('website' => 'shoobedobop'));
@@ -719,6 +1194,17 @@ public function testUrlInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testUrlInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('website' => 'thisisjusttext'));
+        $v->rules(array(
+            'url' => array(
+                array('website')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testUrlActive()
     {
         $v = new Validator(array('website' => 'http://google.com'));
@@ -726,6 +1212,17 @@ public function testUrlActive()
         $this->assertTrue($v->validate());
     }
 
+    public function testUrlActiveValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('website' => 'https://example.com/contact'));
+        $v->rules(array(
+            'urlActive' => array(
+                array('website')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testUrlInactive()
     {
         $v = new Validator(array('website' => 'http://example-test-domain-' . md5(time()) . '.com'));
@@ -733,6 +1230,17 @@ public function testUrlInactive()
         $this->assertFalse($v->validate());
     }
 
+    public function testUrlActiveInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('website' => 'https://example-domain'));
+        $v->rules(array(
+            'urlActive' => array(
+                array('website')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testAlphaValid()
     {
         $v = new Validator(array('test' => 'abcDEF'));
@@ -740,6 +1248,17 @@ public function testAlphaValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testAlphaValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'batman'));
+        $v->rules(array(
+            'alpha' => array(
+                array('username')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testAlphaInvalid()
     {
         $v = new Validator(array('test' => 'abc123'));
@@ -747,6 +1266,17 @@ public function testAlphaInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testAlphaInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => '123456asdf'));
+        $v->rules(array(
+            'alpha' => array(
+                array('username')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testAlphaNumValid()
     {
         $v = new Validator(array('test' => 'abc123'));
@@ -754,6 +1284,17 @@ public function testAlphaNumValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testAlphaNumValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'batman123'));
+        $v->rules(array(
+            'alphaNum' => array(
+                array('username')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testAlphaNumInvalid()
     {
         $v = new Validator(array('test' => 'abc123$%^'));
@@ -761,6 +1302,17 @@ public function testAlphaNumInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testAlphaNumInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'batman123-$'));
+        $v->rules(array(
+            'alphaNum' => array(
+                array('username')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testAlphaDashValid()
     {
         $v = new Validator(array('test' => 'abc-123_DEF'));
@@ -768,6 +1320,17 @@ public function testAlphaDashValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testSlugValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'L337-H4ckZ0rz_123'));
+        $v->rules(array(
+            'slug' => array(
+                array('username')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testAlphaDashInvalid()
     {
         $v = new Validator(array('test' => 'abc-123_DEF $%^'));
@@ -775,6 +1338,17 @@ public function testAlphaDashInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testSlugInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'L337-H4ckZ0rz_123 $%^'));
+        $v->rules(array(
+            'slug' => array(
+                array('username')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testNoErrorFailOnArray()
     {
         $v = new Validator(array('test' => array()));
@@ -789,6 +1363,17 @@ public function testRegexValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testRegexValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'Batman123'));
+        $v->rules(array(
+            'regex' => array(
+                array('username', '/^[a-zA-Z0-9]{5,10}$/')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testRegexInvalid()
     {
         $v = new Validator(array('test' => 'istheanswer'));
@@ -796,6 +1381,17 @@ public function testRegexInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testRegexInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'Batman_123'));
+        $v->rules(array(
+            'regex' => array(
+                array('username', '/^[a-zA-Z0-9]{5,10}$/')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testDateValid()
     {
         $v = new Validator(array('date' => '2013-01-27'));
@@ -803,6 +1399,17 @@ public function testDateValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testDateValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('created_at' => '2018-10-13'));
+        $v->rules(array(
+            'date' => array(
+                array('created_at')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testDateValidWithDateTimeObject()
     {
         $v = new Validator(array('date' => new DateTime()));
@@ -817,6 +1424,17 @@ public function testDateInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testDateInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('created_at' => 'bananas'));
+        $v->rules(array(
+            'date' => array(
+                array('created_at')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     /**
      * @group issue-13
      */
@@ -834,6 +1452,17 @@ public function testDateFormatValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testDateFormatValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('created_at' => '2018-10-13'));
+        $v->rules(array(
+            'dateFormat' => array(
+                array('created_at', 'Y-m-d')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testDateFormatInvalid()
     {
         $v = new Validator(array('date' => 'no thanks'));
@@ -845,6 +1474,17 @@ public function testDateFormatInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testDateFormatInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('created_at' => '10-13-2018'));
+        $v->rules(array(
+            'dateFormat' => array(
+                array('created_at', 'Y-m-d')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testDateBeforeValid()
     {
         $v = new Validator(array('date' => '2013-01-27'));
@@ -852,6 +1492,17 @@ public function testDateBeforeValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testDateBeforeValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('created_at' => '2018-09-01'));
+        $v->rules(array(
+            'dateBefore' => array(
+                array('created_at', '2018-10-13')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testDateWarningsWithObjectParams()
     {
         $v = new Validator(array('startDate' => '2013-01-27', 'endDate' => '2013-05-08'));
@@ -885,6 +1536,17 @@ public function testDateBeforeInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testDateBeforeInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('created_at' => '2018-11-01'));
+        $v->rules(array(
+            'dateBefore' => array(
+                array('created_at', '2018-10-13')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testDateAfterValid()
     {
         $v = new Validator(array('date' => '2013-01-27'));
@@ -892,6 +1554,17 @@ public function testDateAfterValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testDateAfterValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('created_at' => '2018-09-01'));
+        $v->rules(array(
+            'dateAfter' => array(
+                array('created_at', '2018-01-01')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testDateAfterInvalid()
     {
         $v = new Validator(array('date' => '2013-01-27'));
@@ -899,6 +1572,17 @@ public function testDateAfterInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testDateAfterInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('created_at' => '2017-09-01'));
+        $v->rules(array(
+            'dateAfter' => array(
+                array('created_at', '2018-01-01')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testContainsValid()
     {
         $v = new Validator(array('test_string' => 'this is a Test'));
@@ -906,6 +1590,18 @@ public function testContainsValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testContainsValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'Batman123'));
+        $v->rules(array(
+            'contains' => array(
+                array('username', 'man'),
+                array('username', 'man', true)
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testContainsNonStrictValid()
     {
         $v = new Validator(array('test_string' => 'this is a Test'));
@@ -920,6 +1616,17 @@ public function testContainsInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testContainsInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'Batman123'));
+        $v->rules(array(
+            'contains' => array(
+                array('username', 'Man', true)
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testContainsStrictInvalid()
     {
         $v = new Validator(array('test_string' => 'this is a Test'));
@@ -964,6 +1671,17 @@ public function testSubsetValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testSubsetValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('colors' => array('green', 'blue')));
+        $v->rules(array(
+            'subset' => array(
+                array('colors', array('orange', 'green', 'blue', 'red'))
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testSubsetInvalid()
     {
         $v = new Validator(array('test_field' => array(81, false, 'orange')));
@@ -971,6 +1689,17 @@ public function testSubsetInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testSubsetInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('colors' => array('purple', 'blue')));
+        $v->rules(array(
+            'subset' => array(
+                array('colors', array('orange', 'green', 'blue', 'red'))
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testSubsetInvalidValue()
     {
         $v = new Validator(array('test_field' => 'black 45'));
@@ -1009,6 +1738,17 @@ public function testContainsUniqueValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testContainsUniqueValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('colors' => array('purple', 'blue')));
+        $v->rules(array(
+            'containsUnique' => array(
+                array('colors')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testContainsUniqueInvalid()
     {
         $v = new Validator(array('test_field' => array(81, false, 'orange', false)));
@@ -1016,6 +1756,17 @@ public function testContainsUniqueInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testContainsUniqueInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('colors' => array('purple', 'purple')));
+        $v->rules(array(
+            'containsUnique' => array(
+                array('colors')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testContainsUniqueInvalidValue()
     {
         $v = new Validator(array('test_field' => 'lorem ipsum'));
@@ -1286,6 +2037,17 @@ public function testBooleanValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testBooleanValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('remember_me' => true));
+        $v->rules(array(
+            'boolean' => array(
+                array('remember_me')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testBooleanInvalid()
     {
         $v = new Validator(array('test' => 'true'));
@@ -1293,6 +2055,17 @@ public function testBooleanInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testBooleanInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('remember_me' => 'lobster'));
+        $v->rules(array(
+            'boolean' => array(
+                array('remember_me')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testZeroStillTriggersValidation()
     {
         $v = new Validator(array('test' => 0));
@@ -1366,6 +2139,19 @@ public function testInstanceOfValidWithString()
         $this->assertTrue($v->validate());
     }
 
+    public function testInstanceOfValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('date' => new \DateTime()));
+        $existingDateObject = new \DateTime();
+        $v->rules(array(
+            'instanceOf' => array(
+                array('date', 'DateTime'),
+                array('date', $existingDateObject)
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testInstanceOfInvalidWithInstance()
     {
         $v = new Validator(array('attributeName' => new stdClass()));
@@ -1373,6 +2159,17 @@ public function testInstanceOfInvalidWithInstance()
         $this->assertFalse($v->validate());
     }
 
+    public function testInstanceOfInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('date' => new \DateTime()));
+        $v->rules(array(
+            'instanceOf' => array(
+                array('date', 'stdClass')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testInstanceOfValidWithInstance()
     {
         $v = new Validator(array('attributeName' => new stdClass()));
@@ -1459,6 +2256,20 @@ public function testOptionalProvidedValid()
         $this->assertTrue($v->validate());
     }
 
+    public function testOptionalProvidedValidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'batman'));
+        $v->rules(array(
+            'alpha' => array(
+                array('username')
+            ),
+            'optional' => array(
+                array('username')
+            )
+        ));
+        $this->assertTrue($v->validate());
+    }
+
     public function testOptionalProvidedInvalid()
     {
         $v = new Validator(array('address' => 'userexample.com'));
@@ -1466,6 +2277,34 @@ public function testOptionalProvidedInvalid()
         $this->assertFalse($v->validate());
     }
 
+    public function testChainingRules()
+    {
+        $v = new Valitron\Validator(array('email_address' => 'test@test.com'));
+        $v->rule('required', 'email_address')->rule('email', 'email_address');
+        $this->assertTrue($v->validate());
+    }
+
+    public function testNestedDotNotation()
+    {
+        $v = new Valitron\Validator(array('user' => array('first_name' => 'Steve', 'last_name' => 'Smith', 'username' => 'Batman123')));
+        $v->rule('alpha', 'user.first_name')->rule('alpha', 'user.last_name')->rule('alphaNum', 'user.username');
+        $this->assertTrue($v->validate());
+    }
+
+    public function testOptionalProvidedInvalidAltSyntax()
+    {
+        $v = new Valitron\Validator(array('username' => 'batman123'));
+        $v->rules(array(
+            'alpha' => array(
+                array('username')
+            ),
+            'optional' => array(
+                array('username')
+            )
+        ));
+        $this->assertFalse($v->validate());
+    }
+
     public function testOptionalNotProvided()
     {
         $v = new Validator(array());