NAME
    Kelp::Module::ValidateTiny - Validate parameters in a Kelp Route Handler

VERSION
    Version 0.01

SYNOPSIS
        use Kelp::Module::ValidateTiny;
        # inside your Kelp config file 
        {
            modules => [ qw{SomeModule Validate::Tiny} ],
            modules_init => {
                ...
                ,
                # :all will import everything
                # no need to list MyApp here
                'Validate::Tiny' => {
                    subs => [ qw{is_required is_required_id} ],
                    into => [ qw{MyApp::OtherRouteClass} ], 
                }
            }
        }
        ...
        #inside a Kelp route

        my $vt_rules = {
            fields => [...],
            filters => [...],
            checks => [...],
        };
    
        my $result = $self->validate($vt_rules)
        # $result is a Validate::Tiny object

        # process $result
        ...
    
        # render the template form.tt if validation fails
        # $errors and valid values are automatically passed, 
        # to the template, but you can optionally pass some 
        # more data to that template

        my $result = $self->validate($rules, 
            on_error => 'form.tt',
            data => {
                message => 'You could try something else'
            },
        );
        # If validation fails, $result is an instance of 
        # Validate::Tiny::PlackResponse and has a response 
        # method that can be sent
        return $result->response unless $result->success
    
        # All data is valid here.
        # use $result->data

DESCRIPTION
    Kelp::Module::ValidateTiny adds Validate::Tiny's validator to your Kelp
    application.

METHODS
  validate
    This is the only method decorating $self. You can call it in three ways:

    First you can pass it just a valid Validate::Tiny $rules hash reference.
    It will return a Validate::Tiny object and you can call all the usual
    V::T methods on it.

        my $result = $self->validate($rules);
        # $result is now a Validate::Tiny object

    Second you can pass it a name ('on_error') and value (a template
    filename) pair. If your data passed the validation, the return value is
    the usual V::T object. However, if validation fails, the validate method
    returns an object that has a "response" method in addition to all the
    Validate::Tiny methods.

        my $result = $self->validate(
            $rules,
            on_error => 'form'
        );
        return $result->response unless $result->success # form.tt rendered
        ...
        # Your data was valid here
        ...
        # Return some other response

    Note that calling $result->response if your validations succeeded is a
    fatal error. The template (form.tt in the code above) is rendered with a
    hashref that contains the key-value pairs of valid parameters plus a key
    "error" that points to another hashref with names of invalid parameters
    as keys and the corresponding error messages as values. So if your
    parameters were

        {id => 41, lang => 'Perl', version => '5.10'}

    and id was found to be invalid with your rules/checks, then the template
    'form.tt' renderer is passed the following hashref:

        {
            lang => 'Perl',
            version => '5.10',
            error {
                    id => 'The answer is 42, not 41',
            }
        }

    This can be useful with a construct like "[% error.name || name %]" in
    your template.

    Third, you can pass some additional values that will be passed "as is""
    to the on_fail template

        $self->validate($rules, 
            on_error => 'form.tt',
            data => {
                message => 'You could try something else next time!'
            },
        );

    Here the caller passes an additional key data so that your "on_error"
    template renderer gets the following hash ref

        {
            lang => 'Perl',
            version => '5.10',
            error {
                id => 'The answer is 42, not 41',
            },
            message => 'You could try something else next time!'
        }

AUTHOR
    Gurunandan R. Bhat <gbhat@pobox.com>

COPYRIGHT
    Copyright 2013- Gurunandan R. Bhat

LICENSE
    This library is free software; you can redistribute it and/or modify it
    under the same terms as Perl itself.

SEE ALSO
    Kelp, Kelp::Module, Validate::Tiny

