Data::FormValidator::Constraints::HTTP - Simple Data::FormValidator constraint methods for checking various HTTP methods.


    use Data::FormValidator;
    use Data::FormValidator::Constraints::HTTP qw( POST );
    my %input = (
        method => $request->method,
        author => $request->parameter('author'),
        name   => $request->parameter('name'),
    my %profile = (
        required           => [ qw( method author ) ],
        optional           => [ qw( name ) ],
        constraint_methods => {
            method         => POST,
    my $results = Data::FormValidator->check( \%input, \%profile );
    # If $request->method was not 'POST', then this form validation 
    # will not be successful.


This module provides some simple, Data::FormValidator compatible constraint methods for validating HTTP request methods. For example, it may be desirable to consider a form invalid until the request method is POST.


I have found this technique of making forms invalid unless the request method is POST to be rather useful within the Catalyst web framework, using the FormValidator and FillInForm plugins.

The FillInForm plugin will automatically fill in an HTML form with the values located in $c->request->parameters *AS LONG AS THE CURRENT FORM IS INVALID*. We can use this behaviour to make our lives simpler. By placing the HTTP method constraint method in our validation profile, we can be guaranteed that FillInForm will engage if the method is not POST (it may still engage even if the method *IS* POST, depending on the form validation profile and the client's provided input).

    package My::App;
    use Catalyst qw( Static::Simple FillInForm FormValidator );
    package My::App::Controller::Root;
    use base qw( Catalyst::Controller );
    sub auto : Private {
        my ($self, $c) = @_;
        # The HTTP request method must be placed into the request 
        # parameters in order for the FormValidator plugin to check it.
        # This can easily be done in the root controller's "auto" 
        # action to avoid this in the various controllers.
        # Just another tip to make the code cleaner. :)
        $c->request->parameter( method => $c->request->method );
    package My::App::Controller::Foo;
    use Data::FormValidator::Constraints::HTTP qw( POST );
    sub update : Local {
        my ($self, $c, $foo) = @_;
        $foo = $c->model('Schema::Foo')->find( $foo );
            required           => [ qw( method name author ) ],
            constraint_methods => {
                method         => POST,
                name           => FV_min_length( 6 ),
                # ... yadda, yadda, yadda
        if ($c->form->success) {
            # you can be sure this will only be reached if the request 
            # method is POST and the rest of the request parameters 
            # have successfully passed the rest of your form validation 
            # profile.
            $foo->update_from_form( $c->form );
        else {
            # By setting the parameters in this manner, FillInForm will 
            # automatically fill in the HTML form using the current 
            # object values, being overridden by any request parameters 
            # already specified. Meaning, if $foo get a field called 
            # 'title' and its value had already been set, FillInForm 
            # will place that value into the HTML form being presented 
            # to the client. However, if the request parameters include 
            # a value for 'title', *THAT* value gets placed in the 
            # HTML form.
                %{ $c->request->parameters },


http_method ( $method )

Returns a constraint method to determine whether or not a method is equal to the provided variable.


GET ( )


POST ( )

PUT ( )


Returns a constraint method to determine whether or not a method is equal to the name of the rule (i.e. - GET, POST, PUT, etc...).


  • Data::FormValidator

  • Data::FormValidator::Constraints

  • Catalyst


Adam Paynter <>


Copyright 2006 by Adam Paynter

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