Download the PHP package samrap/laravel-validation without Composer

On this page you can find all versions of the php package samrap/laravel-validation. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.

FAQ

After the download, you have to make one include require_once('vendor/autoload.php');. After that you have to import the classes with use statements.

Example:
If you use only one package a project is not needed. But if you use more then one package, without a project it is not possible to import the classes with use statements.

In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
Some PHP packages are not free to download and because of that hosted in private repositories. In this case some credentials are needed to access such packages. Please use the auth.json textarea to insert credentials, if a package is coming from a private repository. You can look here for more information.

  • Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
  • To use Composer is sometimes complicated. Especially for beginners.
  • Composer needs much resources. Sometimes they are not available on a simple webspace.
  • If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
  • Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Please rate this library. Is it a good library?

Informations about the package laravel-validation

Laravel Validation

StyleCI Build Status Latest Stable Version Total Downloads Latest Unstable Version License

Laravel Validation


Laravel Validation is a bare-bones, minimal validation package for the Laravel framework. Its only purpose is to provide a way to separate your request validation rules from your models and controllers, neither of which should contain such information. It accomplishes this by essentially acting as a broker between your validation rules and a Laravel validator instance.

But I'm Using Form Requests


If you're using Form Requests, then this package won't be of use. If you prefer to explicitly validate requests from within your controllers but want to keep your validation rules separate, then give Laravel Validation a try!

Installation


Install via Composer:

composer require samrap/laravel-validation

Then add the service provider to your providers array in config/app.php:

Finally, the base Validator class needs to be published to a new app/Validators directory. This can be done using the vendor:publish command:

php artisan vendor:publish --provider="Samrap\Validation\ValidationServiceProvider"

Usage


All validators reside in the app/Validators directory and extend the class App\Validators\Validator. There should be one validator class per model. For example, the validator for a User model could be called UserValidator.

Laravel Validation provides a useful artisan command for generating new validators on the fly. Let's create a validator for our User model and define some rules:

php artisan make:validator UserValidator

This will create a new UserValidator class in the app/Validators directory that looks like this:

Each validator has a rules property which (suitably) houses all the validation rules for the intended model. Let's define some basic rules for this validator:

Great! We now have a validator class named UserValidator with the rules we intend to validate with in our controller. Let's jump over to the UserController and see how to use this new validator class.

First, we will want to import this class into our controller:

use App\Validators\UserValidator

Now, let's validate a POST request for the controller's store method:

A few things are going on here. Let's go line by line.

First, in addition to the current request, we are type hinting an instance of our UserValidator as it has dependencies that should be resolved via the service container:

Our validator inherits a validate method from its parent class, Samrap\Validation\Validator, which we can use to obtain an Illuminate\Validation\Validator instance. Our validate method takes the same arguments as if we were manually creating a validator using Laravel's Validator::make method (more on this later). So, we will simply pass the request input to the $validator->validate() method:

Finally, we can make use of Laravel's ValidatesRequests trait, included by default on all controllers. It provides us with a validateWith method, which expects a validator instance and the request and will handle redirection if the validation fails:

That's it! That is all you need to do to validate your requests. The validator will use the rules defined in your UserValidator to validate the request, in two lines of code in your controller. Obviously, this cleans up your controllers dramatically as the amount of validation you need increases.

Of course, there may be times in a certain request when you need to add to or override some of the rules you defined in your validator. No worries, it's super easy!

In this case, we are adding a rule for a name field, which will be merged with our rules defined in the UserValidator. By default, any rules passed explicitly to the validate method will override the rules defined in the validator if they exist.

Additional Features


Multiple Rulesets

Laravel Validation expects a rules property on your validator class, but it is possible to define additional properties and use those in specific cases. You may have different requirements when updating a record vs storing, or have unique rules if a user is of a specific role.

Let's define an updating property on the App\Validators\UserValidator class with specific rules for updating a user:

Then in our controller's update method, we can call the validator's using method and pass the name of the property we want to validate with:

By calling the using method before validate, we are telling the validator to use the updating property instead of the default rules.

Contributing


Contributions are more than welcome! You can submit feature requests to [email protected], or fork the repo yourself!


All versions of laravel-validation with dependencies

PHP Build Version
Package Version
Requires php Version >=5.5.9
illuminate/support Version ~5.1
illuminate/validation Version ^5.2
phpunit/phpunit Version ^4.8
illuminate/console Version ^5.2
Composer command for our command line client (download client) This client runs in each environment. You don't need a specific PHP version etc. The first 20 API calls are free. Standard composer command

The package samrap/laravel-validation contains the following files

Loading the files please wait ....