Validator refactored to be OO
This is a really solid start. I only have a couple of suggestions.


Instead of defining the rules outside of the Validator class, it might be a good idea to sub class Validator and set the rules inside the constructor.
Create public methods specifically for each kind of validator.


Some pseudo code to get the main idea:

validator.php

class Validator
{
    private $rule_collection = array();

    public function __construct()
    {
    }

    public function ruleFor($property)
    {
        if (!isset($this-&gt;rule_collection[$property]))
            $this-&gt;rule_collection[$property] = new RuleBuilder($property);

        return $this-&gt;rule_collection[$property];
    }

    public function validate($model)
    {
        $valid = true;

        foreach ($this-&gt;rule_collection as $property =&gt; $rule_builder)
        {
            foreach ($rule_builder-&gt;rules as $rule)
            {
                if (!$rule-&gt;validate($model-&gt;$property))
                    $valid = false;
            }
        }

        return $valid;
    }
}


rule_builder.php

interface IRule
{
    public validate($value);
    public get_message();
}

class RuleBuilder
{
    private $property;
    public $rules = array();

    public function __construct($property)
    {
        $this-&gt;property = $property;
    }

    public function isRequired()
    {
        return $this-&gt;addRule(new RequiredRule());
    }

    public function length($min, $max = -1)
    {
        return $this-&gt;addRule(new LengthRule($min, $max));
    }

    public function addRule(IRule $rule)
    {
        $this-&gt;rules[] = $rule;
        return $this;
    }
}


And your specific validator:

class UserValidator extends Validator
{
    public function __construct()
    {
        $this-&gt;ruleFor('name')
            -&gt;isRequired()
            -&gt;length(20);
    }
}


To use it:

$user = new User();
$user-&gt;name = "Foo";
$validator = new UserValidator();

if ($validator-&gt;validate($user))
    // save
else
    // redraw form and show errors


This way all of your rule classes are hidden. All of the validation rules are portable because they are created inside a model specific class, and it's easy to use an IDE's auto complete feature to discover which rules are available since the RuleBuilder class has strongly typed methods encapsulating each rule.

On top of that, the IRule interface just accepts a value and not a model, making each rule unit testable to ensure your validation library is functioning properly.

And for those who do some .NET/C# development, this pattern probably looks familiar if you've used the FluentValidation NuGet package for Visual Studio. Say what you want about .NET development, but there are some gems out there. I do like the pattern that FluentValidation uses.