++ed by:

1 non-PAUSE user.

Gurunandan Bhat
and 1 contributors

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