[李景山php]每天laravel-20160927|Factory.php

<?php

namespace Illuminate\Validation;

use Closure;
use Illuminate\Support\Str;
use Illuminate\Contracts\Container\Container;
use Symfony\Component\Translation\TranslatorInterface;
use Illuminate\Contracts\Validation\Factory as FactoryContract;
// more Str
class Factory implements FactoryContract
{// Class Factory implements FactoryContract
    /**
     * The Translator implementation.
     *
     * @var \Symfony\Component\Translation\TranslatorInterface
     */
    protected $translator;//The Translator implementation.

    /**
     * The Presence Verifier implementation.
     *
     * @var \Illuminate\Validation\PresenceVerifierInterface
     */
    protected $verifier;// The Presence Verifier implementation

    /**
     * The IoC container instance.
     *
     * @var \Illuminate\Contracts\Container\Container
     */
    protected $container;//The IoC container instance

    /**
     * All of the custom validator extensions.
     *
     * @var array
     */
    protected $extensions = [];//All of the custom validator extensions
    // no time is out


    /**
     * All of the custom implicit validator extensions.
     *
     * @var array
     */
    protected $implicitExtensions = [];//All of the custom implicit validator extensions

    /**
     * All of the custom validator message replacers.
     *
     * @var array
     */
    protected $replacers = [];//All of the custom validator message replacers.

    /**
     * All of the fallback messages for custom rules.
     *
     * @var array
     */
    protected $fallbackMessages = [];//All of the fallback messages for custom rules.

    /**
     * The Validator resolver instance.
     *
     * @var Closure
     */
    protected $resolver;// The Validator resolver instance.

    /**
     * Create a new Validator factory instance.
     *
     * @param  \Symfony\Component\Translation\TranslatorInterface  $translator
     * @param  \Illuminate\Contracts\Container\Container  $container
     * @return void
     */
    public function __construct(TranslatorInterface $translator, Container $container = null)
    {
        $this->container = $container;// Get container set
        $this->translator = $translator;//translator set
    }// Create a new Validator factory instance.

    /**
     * Create a new Validator instance.
     *
     * @param  array  $data
     * @param  array  $rules
     * @param  array  $messages
     * @param  array  $customAttributes
     * @return \Illuminate\Validation\Validator
     */
    public function make(array $data, array $rules, array $messages = [], array $customAttributes = [])
    {// make data rules messages customAttributes
        // The presence verifier is responsible for checking the unique and exists data
        // for the validator. It is behind an interface so that multiple versions of
        // it may be written besides database. We'll inject it into the validator.
        $validator = $this->resolve($data, $rules, $messages, $customAttributes);
        // The presence verifier is responsible for checking the unique and exists data
        // for the validator.It is behind an interface so that multiple versions of it
        // may be written besides database. We'll inject it into the validator.

        // what ever ,get a unique value.

        if (! is_null($this->verifier)) {
            $validator->setPresenceVerifier($this->verifier);
        }// if it is not null

        // Next we'll set the IoC container instance of the validator, which is used to
        // resolve out class based validator extensions. If it is not set then these
        // types of extensions will not be possible on these validation instances.
        if (! is_null($this->container)) {
            $validator->setContainer($this->container);
        }//Next we'll set the IoC container instance of the validator, which is used to
        // resolve out class based validator extensions. If it is not set then these
        // types of extensions will not be possible on these validation instances.

        $this->addExtensions($validator);//add Extensions.

        return $validator;//return validator
    }// make in this create a new validator instance

    /**
     * Add the extensions to a validator instance.
     *
     * @param  \Illuminate\Validation\Validator  $validator
     * @return void
     */
    protected function addExtensions(Validator $validator)
    {// Add the extensions to a validator instance
        $validator->addExtensions($this->extensions);//use this validator to add extensions

        // Next, we will add the implicit extensions, which are similar to the required
        // and accepted rule in that they are run even if the attributes is not in a
        // array of data that is given to a validator instances via instantiation.
        $implicit = $this->implicitExtensions;// get the implicit extension

        $validator->addImplicitExtensions($implicit);// add Implicit Extensions

        $validator->addReplacers($this->replacers);// add Replacers

        $validator->setFallbackMessages($this->fallbackMessages);// set fall back messages
    }

    /**
     * Resolve a new Validator instance.
     *
     * @param  array  $data
     * @param  array  $rules
     * @param  array  $messages
     * @param  array  $customAttributes
     * @return \Illuminate\Validation\Validator
     */
    protected function resolve(array $data, array $rules, array $messages, array $customAttributes)
    {// set this resolve parameters
        if (is_null($this->resolver)) {
            return new Validator($this->translator, $data, $rules, $messages, $customAttributes);
        }//determine null
        // return a new Validator
// call_user_func
        return call_user_func($this->resolver, $this->translator, $data, $rules, $messages, $customAttributes);
    }// Resolve a new Validator instance.

    /**
     * Register a custom validator extension.
     *
     * @param  string  $rule
     * @param  \Closure|string  $extension
     * @param  string  $message
     * @return void
     */
    public function extend($rule, $extension, $message = null)
    {
        $this->extensions[$rule] = $extension;// key is rules, value is the extension

        if ($message) {
            $this->fallbackMessages[Str::snake($rule)] = $message;
        }// if has messages fallback Messages
    }//Register a extend

    /**
     * Register a custom implicit validator extension.
     *
     * @param  string   $rule
     * @param  \Closure|string  $extension
     * @param  string  $message
     * @return void
     */
    public function extendImplicit($rule, $extension, $message = null)
    {
        $this->implicitExtensions[$rule] = $extension;// implicit Extensions

        if ($message) {// message
            $this->fallbackMessages[Str::snake($rule)] = $message;
        }// fallback Messages
    }// Register a custom implicit validator extension

    /**
     * Register a custom implicit validator message replacer.
     *
     * @param  string   $rule
     * @param  \Closure|string  $replacer
     * @return void
     */
    public function replacer($rule, $replacer)
    {
        $this->replacers[$rule] = $replacer;// set the replacer array use key and value
    }//Register a custom implicit validator message replacer.

    /**
     * Set the Validator instance resolver.
     *
     * @param  \Closure  $resolver
     * @return void
     */
    public function resolver(Closure $resolver)
    {
        $this->resolver = $resolver;
    }// set the resolver

    /**
     * Get the Translator implementation.
     *
     * @return \Symfony\Component\Translation\TranslatorInterface
     */
    public function getTranslator()
    {
        return $this->translator;
    }// get Translator

    /**
     * Get the Presence Verifier implementation.
     *
     * @return \Illuminate\Validation\PresenceVerifierInterface
     */
    public function getPresenceVerifier()
    {
        return $this->verifier;
    }// get Presenceverifier

    /**
     * Set the Presence Verifier implementation.
     *
     * @param  \Illuminate\Validation\PresenceVerifierInterface  $presenceVerifier
     * @return void
     */
    public function setPresenceVerifier(PresenceVerifierInterface $presenceVerifier)
    {
        $this->verifier = $presenceVerifier;
    }// big set
}