Uniqueness

Since validation rules are declared as static, it is not possible to use instance variables to validate models for uniqueness?

When updating a user for example, you want to ignore uniqueness for the user being updated. You can do this by specifying the ID of the model to ignore. Otherwise the validation rules will fail as the user you are updating has the same email address as the user you are updating.

'email' => 'unique:users,email_address,10'

By using a Validator service you can pass an instance of the model into a method and return a validator object for that model which you can check on save.

namespace Models\Services\Validators;

use Models\User;
use Validator;

class UserValidator {

    public static function getValidator(User $user) {
        $rules = [
            'first_name'  => 'required|max:50',
            'last_name'   => 'required|max:50',
            'email'       => "required|max:100|email|unique:users,email{$user->id}"
        ];

        return Validator::make($user->toArray(), $rules);
    }

}

You can't do this with a static variable on a model.

// This will fail if you are updating an existing user.
public static $rules = array(
    'email' => 'required|email|unique,users,email',
);

[laravelbook]

@grbsn - You've proposed a nice design pattern! 👍
As for your original problem: Ardent provides a mechanism to override static rules. validate() and save() (and also forceSave() ) methods have the $rules parameter in which you may pass custom validation rules.

I've just posted a small snippet here

[shkm]

I look forward to such an elegant solution! For now, in order to keep validation in the model, I went ahead and overrode validate() with my own rules.

public function validate($rules = array(), $customMessages = array())
{
    if (empty($rules)) {
        $rules = array(
            'slug' => 'required|alpha_dash|between:1,128|unique:pages,slug,' . $this->id,
        );
    }

    return parent::validate($rules, $customMessages);
}

Would it be a good idea to remodel validation to follow this pattern?

[laravelbook]

@grbsn Sure! Please do go ahead and share your ideas...

I'm thinking Factory pattern here...

Here's some pseudo-code off the top of my head...

Interface definition:

public interface ICustomValidatorFactory {
    public function makeValidator(/* Eloquent */ $entity) { }
}

Implementation:

public class UserValidatorFactory extends ICustomValidatorFactory {

    public function makeValidator(\User $user) {
         $rules = [... custom validation rules ...];
         $customMessages = [... custom error messages ...];

         return \Validator::make($user->toArray(), $rules, $customMessages);
    }

}

Modifications to Ardent base class:

class Ardent
{
    public ICustomValidatorFactory $validatorFactory;

    public function validate( $rules = array(), $customMessages = array() ) {

        // auto-hydrate entity attributes from Input
        if ( $this->autoHydrateEntityFromInput ) {
            $attributes = array_intersect_key( Input::all(), $rules );
            foreach ( $attributes as $key => $value ) {
                $this->setAttribute( $key, $value );
            }
        }

        $validator = null;

        if ( !is_null( $this->validatorFactory ) ) {
            $validator = $this->validatorFactory->makeValidator($this);
        }

        if ( is_null( $validator ) ) {
            // fallback - instantiate the validator manually... (extra code removed for succinctness)
            $validator = Validator::make( $this->attributes, $rules, $customMessages );
        }

        $success = $validator->passes();
        // ... rest of the code
    }

}

Route/Controller code:
New user creation:

Route::post('create/new/user', function () {
    $user = new User;
    $user->save();
});

Modify existing user (uses custom validator):

Route::post('update/existing/user/(:num)', function ($id) {
    $user = User::find($id);
    $user->validatorFactory = new UserValidatorFactory();
    $user->update();
});

What do you think?

Update: It's not a proper factory method... but you get the idea...

I don't actually know how Ardent validates, do you call the validator on save() method? Something like this could be a possible implementation.

<?php namespace Ardent;

use Illuminate\Database\Eloquent\Model as Eloquent;
use Illuminate\Support\Facades\Validator;

abstract class ValidatorServiceProvider {

    public $model;
    public $rules;
    public $messages;

    public function __construct(Eloquent $model, $rules = [], $messages = [])

        $this->model = $model;
        $this->rules = $rules;
        $this->messages = $messages;
    }

    public function getMessages()
    {
        return $this->messages;
    }

    public function setMessages($messages)
    {
        $this->messages = $messages;
    }

    public function getRules()
    {
        return $this->rules;
    }

    public function setRules($rules)
    {
        $this->rules = $rules;
    }

    public function getValidator()
    {
        return Validator::make($this->model->toArray(), $this->rules, $this->messages);
    }

}

<?php namespace Ardent;

use \User;

class UserValidator extends ValidatorServiceProvider {

    public function __construct(User $user)
    {
        parent::__construct($user);

        $this->rules = [
            'id' => 'required|integer'
        ];
    }

}

[laravelbook]

@grbsn Ardent->save() method invokes Ardent->validate() internally:

    public function save( array $rules = array(), $customMessages = array(), ... ) {
        $validated = $this->validate( $rules, $customMessages );
        // ... rest of the code
    }

Laravel comes pre-equipped with a powerful IoC container. We could leverage that class to inject custom validator providers into our model objects as needed (which may/may not render the factory pattern somewhat redundant...)

Here's a possible usage scenario...

// bootstrap code:
App::bind('existingUser', function($id) {
    $user = User::find($id);
    $user->validatorFactory = new UserValidatorFactory;
    return $user;
});

// usage:
Route::post('update/existing/user/(:num)', function ($id) {
    $user = App::make('existingUser', $id);
    $user->update();
});

... alternatively, dependency injection via constructor:

App::bind('ICustomValidatorFactory', 'UserValidatorFactory');

abstract class Ardent extends Model {

    public function __construct( array $attributes = array(), ICustomValidatorFactory $validatorFactory ) {
        parent::__construct( $attributes );
        $this->validationFactory = $validationFactory;
        $this->validationErrors = new MessageBag;
    }  
}

However, I'm not too fond of messing with the constructor... not sure if Laravels IoC provides DI via property (or "setter" method)..

[jrahmy]

For dealing with the original issue, I do this in my edit routes:

$rules = Entity::$rules;
foreach ($rules as &$rule) {
    $rule = array_filter($rule, function($rule) {
        if (String::startsWith($rule, 'unique:')) {
            return false;
        }
        return true;
    });
}

if ($entity->save($rules)) { ...

Will probably move that to a static method in my base model at some point, and it requires array syntax for the rules.

[JonathanHindi]

Any updates on this issue... Facing the same problem.

[andrew13]

Yeah this will alleviate an issue I'm having as well. For now I'm passing in a different rules array when updating.

[jrahmy]

If you extend Ardent with your own model class, you can do..

    public function validate($rules = array(), $customMessages = array())
    {
        if (empty($rules) and $this->exists)
        {
            $rules = static::$rules;

            foreach ($rules as &$rule) {
                $rule = array_filter($rule, function($rule) {
                    if (String::startsWith($rule, 'unique:')) {
                        return false;
                    }
                    return true;
                });
            }
        }

        return parent::validate($rules, $customMessages);
    }

It will strip all unique rules if the model already exists in the database. All your models have to extend your custom model class instead of Ardent.

[ockam]

CakePHP 2 use a nice pattern for that. You can specify if a rule apply:

• only if field is present in model (required: false)
• all the time (required: true)
• on create or update ( required: create, required: update)

http://book.cakephp.org/2.0/en/models/data-validation.html#required

Don't know how this could be implemented in Ardent, but It could use a less confusing term than required.

[andrew13]

I really like the cakephp 2 way

required | required:create | required:update

I would love to see that added