├── tests
    ├── .gitkeep
    └── Database
    │   └── ModelTest.php
├── .gitignore
├── .travis.yml
├── composer.json
├── phpunit.xml
├── src
    └── Way
    │   └── Database
    │       ├── DatabaseServiceProvider.php
    │       └── Model.php
└── readme.md


/tests/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor
2 | composer.phar
3 | composer.lock
4 | .DS_Store


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php: 
 4 |   - 5.3
 5 |   - 5.4
 6 | 
 7 | before_script:
 8 |   - curl -s http://getcomposer.org/installer | php
 9 |   - php composer.phar install --dev
10 | 
11 | script: phpunit


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "way/database",
 3 |     "description": "",
 4 |     "authors": [
 5 |         {
 6 |             "name": "Jeffrey Way",
 7 |             "email": "jeffrey@jeffrey-way.com"
 8 |         }
 9 |     ],
10 |     "require": {
11 |         "php": ">=5.4.0",
12 |         "illuminate/support": "~4.1",
13 |         "illuminate/database": "~4.1",
14 |         "illuminate/validation": "~4.1"
15 |     },
16 |     "require-dev": {
17 |         "mockery/mockery": "dev-master"
18 |     },
19 |     "autoload": {
20 |         "psr-0": {
21 |             "Way\\Database": "src/"
22 |         }
23 |     },
24 |     "minimum-stability": "stable"
25 | }
26 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit backupGlobals="false"
 3 |          backupStaticAttributes="false"
 4 |          bootstrap="vendor/autoload.php"
 5 |          colors="true"
 6 |          convertErrorsToExceptions="true"
 7 |          convertNoticesToExceptions="true"
 8 |          convertWarningsToExceptions="true"
 9 |          processIsolation="false"
10 |          stopOnFailure="false"
11 |          syntaxCheck="false"
12 | >
13 |     <testsuites>
14 |         <testsuite name="Package Test Suite">
15 |             <directory suffix=".php">./tests/</directory>
16 |         </testsuite>
17 |     </testsuites>
18 | </phpunit>


--------------------------------------------------------------------------------
/src/Way/Database/DatabaseServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Way\Database;
 2 | 
 3 | use Illuminate\Support\ServiceProvider;
 4 | 
 5 | class DatabaseServiceProvider extends ServiceProvider {
 6 | 
 7 | 	/**
 8 | 	 * Indicates if loading of the provider is deferred.
 9 | 	 *
10 | 	 * @var bool
11 | 	 */
12 | 	protected $defer = false;
13 | 
14 | 	/**
15 | 	 * Register the service provider.
16 | 	 *
17 | 	 * @return void
18 | 	 */
19 | 	public function register()
20 | 	{
21 | 		//
22 | 	}
23 | 
24 | 	/**
25 | 	 * Get the services provided by the provider.
26 | 	 *
27 | 	 * @return array
28 | 	 */
29 | 	public function provides()
30 | 	{
31 | 		return array();
32 | 	}
33 | 
34 | }


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | # Auto-Validate On Save
 2 | This package takes care of the model validation process for you. Rather than manually going through the tedious `Validator::make(...)` process, just save the model, and this package will handle the rest.
 3 | 
 4 | ## Usage
 5 | Install the package through Composer.
 6 | 
 7 | ```js
 8 | {
 9 |     "require": {
10 |         "laravel/framework": "4.0.*",
11 |         "way/database": "dev-master"
12 |     }
13 | }
14 | ```
15 | 
16 | Then, rather than extending `Eloquent` from your model, extend `Way\Database\Model`, like so:
17 | 
18 | ```php
19 | <?php
20 | 
21 | class Dog extends Way\Database\Model {
22 | 
23 | }
24 | ```
25 | 
26 | Alternatively, edit `app/config/app.php`, and add a new item to the `aliases` array:
27 | 
28 | ```php
29 | 'Model' => 'Way\Database\Model'
30 | ```
31 | Now, your models can simply extend `Model`.
32 | 
33 | ```php
34 | <?php
35 | 
36 | class Dog extends Model {
37 | 
38 | }
39 | ```
40 | 
41 | ## Validation
42 | 
43 | This package hooks into Eloquent's `save` event, and automatically validates the model's current attributes against the rules that you have set for your model.
44 | 
45 | Here's an example of setting validation rules for the model:
46 | 
47 | ```php
48 | <?php
49 | 
50 | class Dog extends Model {
51 |     protected static $rules = [
52 |         'name' => 'required'
53 |     ];
54 | 
55 |     //Use this for custom messages
56 |     protected static $messages = [
57 |         'name.required' => 'My custom message for :attribute required'
58 |     ];
59 | }
60 | ```
61 | 
62 | Now, simply save the model as you normally would, and let the package worry about the validation. If it fails, then the model's `save` method will return false.
63 | 
64 | Here's an example of storing a new dog.
65 | 
66 | ```php
67 | public function store()
68 | {
69 |     $dog = new Dog(Input::all());
70 | 
71 |     if ($dog->save())
72 |     {
73 |         return Redirect::route('dogs.index');
74 |     }
75 | 
76 |     return Redirect::back()->withInput()->withErrors($dog->getErrors());
77 | }
78 | ```
79 | 
80 | If using Eloquent's static `create` method, you can use the `hasErrors()` methods to determine if validation errors exist.
81 | 
82 | ```php
83 | $dog = Dog::create(Input::all());
84 | 
85 | if ($dog->hasErrors()) ...
86 | ```
87 | That's it! Have fun.
88 | 


--------------------------------------------------------------------------------
/src/Way/Database/Model.php:
--------------------------------------------------------------------------------
  1 | <?php namespace Way\Database;
  2 | 
  3 | use Illuminate\Database\Eloquent\Model as Eloquent;
  4 | use Illuminate\Validation\Validator;
  5 | 
  6 | class Model extends Eloquent {
  7 | 
  8 |     /**
  9 |      * Error message bag
 10 |      * 
 11 |      * @var Illuminate\Support\MessageBag
 12 |      */
 13 |     protected $errors;
 14 | 
 15 |     /**
 16 |      * Validation rules
 17 |      * 
 18 |      * @var Array
 19 |      */
 20 |     protected static $rules = array();
 21 | 
 22 |     /**
 23 |      * Custom messages
 24 |      * 
 25 |      * @var Array
 26 |      */
 27 |     protected static $messages = array();
 28 | 
 29 |     /**
 30 |      * Validator instance
 31 |      * 
 32 |      * @var Illuminate\Validation\Validators
 33 |      */
 34 |     protected $validator;
 35 | 
 36 |     public function __construct(array $attributes = array(), Validator $validator = null)
 37 |     {
 38 |         parent::__construct($attributes);
 39 | 
 40 |         $this->validator = $validator ?: \App::make('validator');
 41 |     }
 42 | 
 43 |     /**
 44 |      * Listen for save event
 45 |      */
 46 |     protected static function boot()
 47 |     {
 48 |         parent::boot();
 49 | 
 50 |         static::saving(function($model)
 51 |         {
 52 |             return $model->validate();
 53 |         });
 54 |     }
 55 | 
 56 |     /**
 57 |      * Validates current attributes against rules
 58 |      */
 59 |     public function validate()
 60 |     {
 61 |         $v = $this->validator->make($this->attributes, static::$rules, static::$messages);
 62 | 
 63 |         if ($v->passes())
 64 |         {
 65 |             return true;
 66 |         }
 67 | 
 68 |         $this->setErrors($v->messages());
 69 | 
 70 |         return false;
 71 |     }
 72 | 
 73 |     /**
 74 |      * Set error message bag
 75 |      * 
 76 |      * @var Illuminate\Support\MessageBag
 77 |      */
 78 |     protected function setErrors($errors)
 79 |     {
 80 |         $this->errors = $errors;
 81 |     }
 82 | 
 83 |     /**
 84 |      * Retrieve error message bag
 85 |      */
 86 |     public function getErrors()
 87 |     {
 88 |         return $this->errors;
 89 |     }
 90 | 
 91 |     /**
 92 |      * Inverse of wasSaved
 93 |      */
 94 |     public function hasErrors()
 95 |     {
 96 |         return ! empty($this->errors);
 97 |     }
 98 | 
 99 | }
100 | 


--------------------------------------------------------------------------------
/tests/Database/ModelTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Way\Database\Model;
 4 | use Mockery as m;
 5 | 
 6 | class ModelTest extends PHPUnit_Framework_TestCase {
 7 | 
 8 |     public function tearDown()
 9 |     {
10 |         m::close();
11 |     }
12 | 
13 |     public function testValidateSuccess()
14 |     {
15 |         // Mock Validator response and make it pass
16 |         $response = m::mock('StdClass');
17 |         $response->shouldReceive('passes')->once()->andReturn(true);
18 | 
19 |         $validation = m::mock('Illuminate\Validation\Validator');
20 |         $validation->shouldReceive('make')
21 |                    ->once()
22 |                    ->andReturn($response);
23 | 
24 |         $model = new Model([], $validation);
25 |         $result = $model->validate();
26 | 
27 |         // If validation passes, we should return true
28 |         // and not set any errors.
29 |         $this->assertTrue($result);
30 |         $this->assertNull($model->getErrors());
31 |     }
32 | 
33 |     public function testValidateFail()
34 |     {
35 |         // Mock Validator response and have it fail
36 |         $response = m::mock('StdClass');
37 |         $response->shouldReceive('passes')->once()->andReturn(false);
38 |         $response->shouldReceive('messages')->once()->andReturn('foo');
39 | 
40 |         $validation = m::mock('Illuminate\Validation\Validator');
41 |         $validation->shouldReceive('make')
42 |                    ->once()
43 |                    ->andReturn($response);
44 | 
45 |         $model = new Model([], $validation);
46 |         $result = $model->validate();
47 | 
48 |         // This time we should return false
49 |         // and store the validation messages
50 |         // on the errors property
51 |         $this->assertFalse($result);
52 |         $this->assertEquals('foo', $model->getErrors());
53 |     }
54 | 
55 |     public function testGetErrors()
56 |     {
57 |         $model = m::mock('Way\Database\Model')->makePartial();
58 |         $model->setErrors('foo');
59 | 
60 |         $this->assertEquals('foo', $model->getErrors());
61 |     }
62 | 
63 |     public function testHasErrors()
64 |     {
65 |         $model = m::mock('Way\Database\Model')->makePartial();
66 | 
67 |         $this->assertFalse($model->hasErrors());
68 | 
69 |         $model->setErrors('foo');
70 | 
71 |         $this->assertTrue($model->hasErrors());
72 |     }
73 | 
74 | }


--------------------------------------------------------------------------------