validate

Params::Validate is a Perl module to validate method/function parameters.

SYNOPSIS

use Params::Validate qw(:all);

# takes named params (hash or hashref)
sub foo
{
validate( @_, { foo => 1, # mandatory
bar => 0, # optional
}
);
}

# takes positional params
sub bar
{
# first two are mandatory, third is optional
validate_pos( @_, 1, 1, 0 );
}


sub foo2
{
validate( @_,
{ foo =>
# specify a type
{ type => ARRAYREF },

bar =>
# specify an interface
{ can => [ print, flush, frobnicate ] },

baz =>
{ type => SCALAR, # a scalar ...
# ... that is a plain integer ...
regex => qr/^d+$/,
callbacks =>
{ # ... and smaller than 90
less than 90 => sub { shift() < 90 },
},
}
}
);
}

sub with_defaults
{
my %p = validate( @_, { foo => 1, # required
# $p{bar} will be 99 if bar is not
# given. bar is now optional.
bar => { default => 99 } } );
}

sub pos_with_defaults
{
my @p = validate_pos( @_, 1, { default => 99 } );
}

sub sets_options_on_call
{
my %p = validate_with
( params => @_,
spec => { foo => { type SCALAR, default => 2 } },
normalize_keys => sub { $_[0] =~ s/^-//; lc $_[0] },
);
}

The Params::Validate module allows you to validate method or function call parameters to an arbitrary level of specificity. At the simplest level, it is capable of validating the required parameters were given and that no unspecified additional parameters were passed in.

It is also capable of determining that a parameter is of a specific type, that it is an object of a certain class hierarchy, that it possesses certain methods, or applying validation callbacks to arguments.

CCard Validate provides a simple check on the validity of Credit Card number.

It just check that the digits are entered correctly, to ensure a card is valid please check with a credit card center.

CGI::Validate is an advanced CGI form parser and type validation.

SYNOPSIS

use CGI::Validate; # GetFormData() only
use CGI::Validate qw(:standard); # Normal use
use CGI::Validate qw(:subs); # Just functions
use CGI::Validate qw(:vars); # Just exception vars

## If you dont want it to check that every requested
## element arrived you can use this. But I dont recommend it
## for most users.
$CGI::Validate::Complete = 0;

## If you dont care that some fields in the form dont
## actually match what you asked for. -I dont recommend
## this unless you REALLY know what youre doing because this
## normally meens youve got typos in your HTML and we cant
## catch them if you set this.
## $CGI::Validate::IgnoreNonMatchingFields = 1;

my $FieldOne = Default String;
my $FieldTwo = 8;
my $FieldThree = some default string;
my @FieldFour = (); ## For multi-select field
my @FieldFive = (); ## Ditto
my $EmailAddress= ;

## Try...
my $Query = GetFormData (
FieldOne=s => $FieldOne, ## Required string
FieldTwo=i => $FieldTwo, ## Required int
FieldThree => $FieldThree, ## Auto converted to the ":s" type
FieldFour=s => @FieldFour, ## Multi-select field of strings
FieldFive=f => @FieldFive, ## Multi-select field of floats
Email=e => $EmailAddress, ## Must look like an email address
) or do {
## Catch... (wouldnt you just love a case statement here?)
if (%Missing) {
die "Missing form elements: " . join ( , keys %Missing);
} elsif (%Invalid) {
die "Invalid form elements: " . join ( , keys %Invalid);
} elsif (%Blank) {
die "Blank form elements: " . join ( , keys %Blank);
} elsif (%InvalidType) {
die "Invalid data types for fields: " . join ( , keys %InvalidType);
} else {
die "GetFormData() exception: $CGI::Validate::Error";
}
};

## If you only want to check the form data, but dont want to
## have CGI::Validate set anything use this. -You still have full
## access to the data via the normal B object that is returned.

use CGI::Validate qw(CheckFormData); # not exported by default
my $Query = CheckFormData (
FieldOne=s, FieldTwo=i, FieldThree, FieldFour,
FieldFive, Email,
) or do {
... Same exceptions available as GetFormData above ...
};

## Need some of your own validation code to be used? Here is how you do it.
addExtensions (
myType => sub { $_[0] =~ /test/ },
fooBar => &fooBar,
i_modify_the_actual_data => sub {
if ($_[0] =~ /test/) { ## data validation
$_[0] = whatever; ## modify the data by alias
return 1;
} else {
return 0;
}
},
);
my $Query = GetFormData (
foo=xmyType => $foo,
bar=xfooBar => $bar,
cat=xi_modify_the_actual_data => $cat,
);


## Builtin data type checks available are:
s string # Any non-zero length value
w word # Must have at least one w char
i integer # Integer value
f float # Float value
e email # Must match m/^s*]+@[^@.<>]+(?:.[^@.<>]+)+>?s*$/
x extension # User extension type. See EXTENSIONS below.

Basicly a blending of the CGI and Getopt::Long modules, and requires the CGI module to function.

The basic concept of this module is to combine the best features of the CGI and Getopt::Long modules. The CGI module is great for parsing, building, and rebuilding forms, however it lacks any real error checking abilitys such as misspelled form input names, the data types received from them, missing values, etc. This however, is something that the Getopt::Long module is vary good at doing. So, basicly this module is a layer that collects the data using the CGI module and passes it to routines to do type validation and name consistency checks all in one clean try/catch style block.

The syntax of GetFormData() is mostly the same as the GetOptions() of Getopt::Long, with a few exceptions (namely, the handling of exceptions) . See the VALUE TYPES section for detail of the available types, and the EXCEPTIONS section for exception handling options. If given without a type, fields are assumed to be type ":s" (optional string), which is normally correct.
If successful, GetFormData() returns the CGI object that it used to parse the data incase you want to use it for anything else, and undef otherwise.

If you only want to do value type and name validation, use CheckFormData() instead with a field=type list. -See the SYNOPSIS for an example.

PEAR Validate is a set of useful methods to validate various kinds of data.

Here are some key features of "PEAR Validate":

· numbers (min/max, decimal or not)
· email (syntax, domain check, rfc822)
· string (predifined type alpha upper and/or lowercase, numeric,...)
· date (min, max)
· uri (RFC2396)
· possibility valid multiple data with a single method call (::multiple)

Makes data validation much easier. This control allows you to collect all of the data validation code for a form into one event procedure. This results in smaller and more maintainable code. Validate only works with controls that have an hWnd property.

Validate Me is a nifty application that will verify your webpage based on W3C web standards from your desktop.

It supports validation for HTML, CSS, and XHTML.

Whats New in This Release:

· No need for the "http://" when entering URLs
· HTML for W3C badge is provided
· Support for XHTML 1.1.

This wizard will let you specify a group of web documents, which can be validated, converted to upper/lowercase, stripped of HTML tags, converted between DOS, Unixand Macintosh text formats, and much more.

Validate at W3C is an AppleScript that gives you a contextual menu item in Opera to submit the current page to the W3Cs HTML validator.
Validate at W3C AppleScript based plug in for FinderPop.

Completly freeware.

Net::Amazon::Validate::ItemSearch is a Perl module to validate ItemSearch requests.

SYNOPSIS

Net::Amazon::Validate::ItemSearch;

my $valid = Net::Amazon::Validate::ItemSearch::factory(search_index => Actor);
my $option = $itemsearch_valid->user_or_default($input);
my $default = $itemsearch_valid->default();

Net::Amazon::Validate::ItemSearch is a class used to verify ItemSearch operation based on the current version of the WSDL and locale. For example if an Artist search is executed the user can search against Classical, Merchants, or Music.

METHODS

factory(search_index => type)

Constructs a new Net::Amazon::Validate::ItemSearch object, used to validate user input for a SearchIndex. Valid types include Actor, Artist, AudienceRating, Author Brand, BrowseNode, City, Composer, Condition, Conductor, Count, Cuisine, DeliveryMethod, Director, ISPUPostalCode, ItemPage, Keywords, MPAARating, Manufacturer, MaximumPrice, MerchantId, MinimumPrice, MusicLabel, Neighborhood, Orchestra, Power, Publisher, Sort, TextStream and Title. Which departments these search indexes are valid for is dependent upon locale.

default()

Return the default value for a given SearchIndex. Default are determined in order of preference and existence from the following list: Books, Music, DVD, Software. If none of those items are valid for a given SearchIndex then the first valid department of said SearchIndex is used.

user_or_default( $input )

If user input is specified it validates the input, and return it, otherwise it returns the default value for the SearchIndex.

Easiest Validate On Submit project enables Web developers to validate any number of form fields, client side (in Javascript), with only one line of code per HTML page.

Here are some key features of "Easiest Validate On Submit":

· It requires only 1 line of javascript per html file, to validate any number of fields in any number of forms.
· The script detects whether you have a div to display errors. If you havent, it puts messages in alert boxes.
· Evos supports styling both the input widgets and the labels upon validation errors.
· Which fields to validate, and which validation (required field, email, numeric) to use, is completely controlled through CSS classes.
· Pluggable custom validation per field, with minimal amounts of code.
· Messages are located in language files, so its easy to display messages in your native language.
· Everything can be styled using CSS.