Result:
found more than 549 distributions - search limited to the first 2001 files matching your query
( run in 2.002 )
Alzabo
view release on metacpan or search on metacpan
lib/Alzabo/BackCompat.pm view on Meta::CPAN
],
);
sub update_schema
{
my %p = validate( @_, { name => { type => SCALAR },
version => { type => SCALAR },
} );
my @cb;
foreach my $c (@compat)
Amazon-CloudFront-SignedURL
view release on metacpan or search on metacpan
lib/Amazon/CloudFront/SignedURL.pm view on Meta::CPAN
return $private_key;
}
sub generate {
my $self = shift;
my $args = $validator->validate(@_);
my $resource = $args->{resource};
my $policy = exists $args->{policy} ? $args->{policy} : undef;
my $expires = exists $args->{expires} ? $args->{expires} : undef;
Amazon-CloudFront-Thin
view release on metacpan or search on metacpan
lib/Amazon/CloudFront/Thin.pm view on Meta::CPAN
=head2 Comparison to alternative modules
There are several useful modules for CloudFront on CPAN, like
L<Paws::CloudFront>, who provide a nice interface. You are welcome
to check them out to see if they suit your needs best. The reason
I wrote Amazon::CloudFront::Thin is because I needed to invalidate
CloudFront paths quickly and easily, and the alternatives felt either
like an "all or nothing" approach or lacked the documentation or
features I needed.
=head2 Amazon CloudFront setup in a Nutshell
lib/Amazon/CloudFront/Thin.pm view on Meta::CPAN
C<aws_secret_access_key>, respectively. Finally, please note that
B<the provided IAM credentials must have the rights to change your CloudFront>.
You can do that by clicking on the user (in the Amazon IAM console where
you created it) and attaching a policy to it, such as the
C<CloudFrontFullAccess> standard policy. Otherwise you'll get errors when
trying to invalidate your CloudFront distributions.
=head1 CONSTRUCTOR
=head2 new( \%params )
lib/Amazon/CloudFront/Thin.pm view on Meta::CPAN
=head2 create_invalidation( @paths )
=head2 create_invalidation( \@paths )
B<Receives>: list of strings (or arrayref of strings), each specifying
a different path to invalidate.
B<Returns>: an L<HTTP::Response> object for the request. Use the C<content()>
method on the returned object to read the contents:
my $res = $cloudfront->create_invalidation( '/path/to/some/object.png' );
Amazon-Dash-Button
view release on metacpan or search on metacpan
lib/Amazon/Dash/Button/Device.pm view on Meta::CPAN
return sub {
print qq{No onClick action defined for this button: } . $_[0]->name . q{\n};
};
}
sub _validate_mac {
my ( $self, $mac ) = @_;
$mac =~ qr{^[0-9a-f:]+$}i or die "invalid mac address";
return 1;
Amazon-DynamoDB
view release on metacpan or search on metacpan
lib/Amazon/DynamoDB/20120810.pm view on Meta::CPAN
my $type = $i->{Projection}->{ProjectionType};
$r->{Projection}->{ProjectionType} = $type;
if (defined($i->{Projection}->{NonKeyAttributes})) {
my $attrs = $i->{Projection}->{NonKeyAttributes};
# Can't validate these attribute names since they aren't part of the key.
$r->{Projection}->{NonKeyAttributes} = $attrs;
}
push @{$payload{$index_type}}, $r;
}
}
Amazon-MWS
view release on metacpan or search on metacpan
lib/Amazon/MWS/XML/Product.pm view on Meta::CPAN
An (optional) arrayref of strings with features (max 5)
=item condition
Possible values which validates correctly: Club CollectibleAcceptable
CollectibleGood CollectibleLikeNew CollectibleVeryGood New Refurbished
UsedAcceptable UsedGood UsedLikeNew UsedVeryGood
Defaults to C<New>
lib/Amazon/MWS/XML/Product.pm view on Meta::CPAN
isa => Int,
default => sub { '2' });
has price => (is => 'ro',
required => 1,
isa => \&_validate_price);
sub _validate_price {
my ($price) = @_;
die "$price is not a number" unless is_Num($price);
die "$price is negative" if $price < 0;
}
has sale_price => (is => 'ro',
isa => \&_validate_price);
has sale_start => (is => 'ro',
isa => sub {
die "Not a datetime"
unless $_[0]->isa('DateTime');
Amazon-S3-Thin
view release on metacpan or search on metacpan
lib/Amazon/S3/Thin.pm view on Meta::CPAN
sub put_object {
my ($self, $bucket, $key, $content, $headers) = @_;
croak 'must specify key' unless $key && length $key;
if ($headers->{acl_short}) {
$self->_validate_acl_short($headers->{acl_short});
$headers->{'x-amz-acl'} = $headers->{acl_short};
delete $headers->{acl_short};
}
if (ref($content) eq 'SCALAR') {
lib/Amazon/S3/Thin.pm view on Meta::CPAN
sub _resource {
my ($self, $bucket, $key, $query_string) = @_;
return Amazon::S3::Thin::Resource->new($bucket, $key, $query_string);
}
sub _validate_acl_short {
my ($self, $policy_name) = @_;
if (!grep({$policy_name eq $_}
qw(private public-read public-read-write authenticated-read)))
{
Amazon-S3
view release on metacpan or search on metacpan
lib/Amazon/S3.pm view on Meta::CPAN
if !$bucket;
my $headers = $conf->{headers} // {};
if ( $conf->{acl_short} ) {
$self->_validate_acl_short( $conf->{acl_short} );
$headers->{'x-amz-acl'} //= $conf->{acl_short};
$headers->{'x-amz-object-ownership'} //= 'ObjectWriter';
}
lib/Amazon/S3.pm view on Meta::CPAN
return $signer;
}
########################################################################
sub _validate_acl_short {
########################################################################
my ( $self, $policy_name ) = @_;
croak sprintf '%s is not a supported canned access policy', $policy_name
if none { $policy_name eq $_ }
Amazon-S3Curl-PurePerl
view release on metacpan or search on metacpan
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
AmberDB
view release on metacpan or search on metacpan
lib/AmberDB.pm view on Meta::CPAN
if ($is_txn) {
$self->{_txn}->{locks}->{"${tableid}_${rid}"} = 1;
}
# Validate and normalize field values according to schema blocks
@record = $self->enc_validate( $tableid, \@record );
# Validate unique constraints across blocks
my ( $unq_ok, $unq_err ) = $self->unique_check( $table_path, $table_info, $rid, \@record );
if ( !$unq_ok ) {
$self->table_close($file_path);
lib/AmberDB.pm view on Meta::CPAN
my ( %statu, @batch, @new_rids );
foreach my $record (@records) {
$record->[0] = $self->table_autoid( $tableid, $record->[0] );
next unless $record->[0];
my ( $rid, @fields ) = @$record;
@fields = $self->enc_validate( $tableid, \@fields );
my ( $unq_ok, $unq_err ) = $self->unique_check( $table_path, $table_info, $rid, \@fields );
if ( !$unq_ok ) {
cluck "[DB_UNIQUE] $unq_err\n";
next;
lib/AmberDB.pm view on Meta::CPAN
return;
}
}
# Validate and normalize field values according to schema blocks
@record = $self->enc_validate( $tableid, \@record );
# Validate unique constraints across blocks
my ( $unq_ok, $unq_err ) = $self->unique_check( $table_path, $table_info, $rid, \@record );
if ( !$unq_ok ) {
$self->table_close($file_path);
lib/AmberDB.pm view on Meta::CPAN
}
$self->table_close($file_path);
unless ($is_txn) { $self->flock_close( $tableid, $rid ); }
# Cache invalidate
$self->cache_delete($tableid, $rid);
my @new_rec = ( $rid, @record );
# text backup record.
lib/AmberDB.pm view on Meta::CPAN
my ( %statu, @pairs );
foreach my $record (@records) {
my ( $rid, @data ) = @$record;
$rid or next;
@data = $self->enc_validate( $tableid, \@data );
my ( $unq_ok, $unq_err ) = $self->unique_check( $table_path, $table_info, $rid, \@data );
if ( !$unq_ok ) {
cluck "[DB_UNIQUE] $unq_err\n";
next;
lib/AmberDB.pm view on Meta::CPAN
}
$self->table_close($file_path);
unless ($is_txn) { $self->flock_close( $tableid, $rid ); }
# Cache invalidate
$self->cache_delete($tableid, $rid);
# Text backup record
$self->recs_back( "del", $tableid, [ $rid, "" ] )
or cluck "[DB_TIE] Backup error (del). $tableid\n";
lib/AmberDB.pm view on Meta::CPAN
# Read from cache (Hard Cache: use_cache == 2)
if ( $use_cache == 2 ) {
my @cached = $self->cache_read($tableid, $rid);
if (@cached) {
my @val_fields = $self->dec_validate( $tableid, \@cached );
return ( $rid, @val_fields );
}
}
# Resolve table path and read record
lib/AmberDB.pm view on Meta::CPAN
# Load access logs
$self->auth_read( $tableid, $table_path, $rid );
if ( @fields > 1 ) {
my $id_val = $fields[0];
my @val_fields = $self->dec_validate( $tableid, [ @fields[ 1 .. $#fields ] ] );
@fields = ( $id_val, @val_fields );
}
return @fields;
}
lib/AmberDB.pm view on Meta::CPAN
unless ($keys_only) {
my $recs_data = $self->recs_get( $scan_path, @records );
foreach my $rec (@records) {
my $val = $recs_data ? $recs_data->{$rec} : undef;
my @decoded = defined $val ? $self->db_decode($val) : ();
my @clean = $self->dec_validate( $tableid, \@decoded );
$rec = [ $rec, @clean ];
}
}
$self->table_close($scan_path);
lib/AmberDB.pm view on Meta::CPAN
my $rid = $links->{$orig_id} || $orig_id;
next if $rec_by_id{$rid};
my @cached_rec = $self->cache_read( $tableid, $rid );
if (@cached_rec) {
my @val_fields = $self->dec_validate( $tableid, \@cached_rec );
$rec_by_id{$rid} = [ $rid, @val_fields ];
}
else {
push @miss_ids, $rid;
}
lib/AmberDB.pm view on Meta::CPAN
my $key_esc = $esc_map{$rid};
my $value = $recs_data->{$rid} // ( defined $key_esc ? $recs_data->{$key_esc} : undef );
next unless defined $value && $value ne '';
my @decoded = $self->db_decode($value);
@decoded = $self->dec_validate( $tableid, \@decoded );
my $rec = [ $rid, @decoded ];
$rec_by_id{$rid} = $rec;
if ( $use_cache == 2 ) {
$self->cache_write( $tableid, $rid, @decoded );
}
lib/AmberDB.pm view on Meta::CPAN
sub {
my ( $key, $value ) = @_;
my %string = $self->get_words( $value, "write", $tableid );
foreach my $str (@tmp) {
if ( $string{$str} ) {
push( @records, [ $key, $self->dec_validate( $tableid, [ $self->db_decode($value) ] ) ] );
return;
}
}
}
);
lib/AmberDB.pm view on Meta::CPAN
foreach my $str (@tmp) {
unless ( $string{$str} ) {
return;
}
}
push( @records, [ $key, $self->dec_validate( $tableid, [ $self->db_decode($value) ] ) ] );
}
);
}
}
$self->table_close($file_path);
lib/AmberDB.pm view on Meta::CPAN
$self->cache_write( $tableid, "keys", @keys );
return @keys;
}
# Sanitizes and validates a record ID according to table id_type (num or ascii).
# For id_type eq 'ascii': cleans non-ASCII chars and enforces deterministic 8-byte limit.
# For id_type eq 'num': enforces numeric digits.
# my $clean_id = $adb->id_check($tableid, $rid);
# ------------------------------------------------
sub id_check {
Ambrosia
view release on metacpan or search on metacpan
lib/Ambrosia/DataProvider.pm view on Meta::CPAN
engine_name => 'IO::CGI',
source_name => 'cgi',
engine_params => {
header_params => {
'-Pragma' => 'no-cache',
'-Cache_Control' => 'no-cache, must-revalidate, no-store'
}
}
}
],
Amethyst
view release on metacpan or search on metacpan
factpacks/Linux.fact view on Meta::CPAN
Link Site => <reply> $who, Weblication to store bookmarks and make them available on the web. URL: http://www.wanetwork.net/linksite/
LinkChecker => <reply> $who, LinkChecker is a URL link checker. URL: http://fsinfo.cs.uni-sb.de/~calvin/?LinkChecker
Links => <reply> $who, Lynx-like text WWW browser. URL: http://artax.karlin.mff.cuni.cz/~mikulas/links/
Links Mananger => <reply> $who, Web-based link directory management system. URL: http://www.gossamer-threads.com/scripts/links/index.htm
Links SQL => <reply> $who, An SQL-based solution to maintain a large web-based directory of links. URL: http://www.gossamer-threads.com/scripts/links-sql/
LinkScan => <reply> $who, checks links, validates HTML and creates SiteMaps. URL: http://www.elsop.com/
LinKT => <reply> $who, Packet-Radio terminal for radio amateurs. URL: http://1409.org/projects/linkt/index.html
linleech => <reply> $who, Program that automates the processof downloading USENET articles. URL: http://cerealbox.suspicion.org/linleech.html
LinNeighborhood => <reply> $who, Linux Port of Windows Network Neighborhood. URL: http://www.bnro.de/~schmidjo/
LinPopup => <reply> $who, Linux port of Winpopup, running over Samba.. URL: http://www.littleigloo.org/
LinPyro => <reply> $who, A pyromaniacs game for Linux.. URL: http://members.tripod.com/~retep/linpyro.html
Amon2-Plugin-Web-CSRFDefender
view release on metacpan or search on metacpan
lib/Amon2/Plugin/Web/CSRFDefender.pm view on Meta::CPAN
$html =~ s!($form_regexp)!qq{$1\n<input type="hidden" name="csrf_token" value="}.$self->get_csrf_defender_token().qq{" />}!ge;
return $html;
},
);
}
unless ($conf->{no_validate_hook}) {
$c->add_trigger(
BEFORE_DISPATCH => sub {
my $self = shift;
if (not $self->validate_csrf()) {
return $self->create_response(
403,
[
'Content-Type' => 'text/html',
'Content-Length' => length($ERROR_HTML)
lib/Amon2/Plugin/Web/CSRFDefender.pm view on Meta::CPAN
my $token = $csrf_token_generator->($self);
$self->session->set('csrf_token' => $token);
$token;
}
});
Amon2::Util::add_method($c, 'validate_csrf', \&validate_csrf);
}
sub validate_csrf {
my $self = shift;
if ( $self->req->method eq 'POST' ) {
my $r_token = $self->req->param('csrf_token') || $self->req->header('x-csrf-token');
my $session_token = $self->session->get('csrf_token');
lib/Amon2/Plugin/Web/CSRFDefender.pm view on Meta::CPAN
=item $c->get_csrf_defender_token()
Get a CSRF defender token. This method is useful to add token for AJAX request.
=item $c->validate_csrf()
You can validate CSRF token manually.
=back
=head1 PARAMETERS
=over 4
=item no_validate_hook
Do not run validation automatically.
=item no_html_filter
Amon2-Plugin-Web-FormValidator-Simple
view release on metacpan or search on metacpan
lib/Amon2/Plugin/Web/FormValidator/Simple.pm view on Meta::CPAN
initial setup.
=item C<< $c->form() >>
validate form/query parameters.
=item C<< $c->set_invalid_form() >>
set error from manual validation.
Amon2
view release on metacpan or search on metacpan
share/flavor/Basic/lib/__PATH__/Web/Plugin/Session.pm view on Meta::CPAN
sub init {
my ($class, $c) = @_;
Amon2::Util::add_method($c, 'xsrf_token', \&_xsrf_token);
Amon2::Util::add_method($c, 'validate_xsrf_token', \&_validate_xsrf_token);
# Ensure and validate XSRF token.
$c->add_trigger(
BEFORE_DISPATCH => sub {
my ( $c ) = @_;
_xsrf_token($c); # initialize on first request
if ($c->req->method ne 'GET' && $c->req->method ne 'HEAD') {
my $token = $c->req->header('X-XSRF-TOKEN')
|| $c->req->param('XSRF-TOKEN');
unless (_validate_xsrf_token($c, $token)) {
return $c->create_simple_status_page(
403, 'XSRF detected.'
);
}
}
share/flavor/Basic/lib/__PATH__/Web/Plugin/Session.pm view on Meta::CPAN
}
return $token;
}
sub _validate_xsrf_token {
my ($self, $token) = @_;
return unless defined $token;
my $session_token = _xsrf_token($self);
return defined $session_token && $token eq $session_token;
Amp-Client
view release on metacpan or search on metacpan
lib/Amp/DbPoolClient.pm view on Meta::CPAN
# find all the ? positions to replace
while ($sql =~ m/\?/g) {
push @replacements, pos($sql);
}
# validate the params given match the number of ? to replace
if (scalar(@replacements) != scalar(@params)) {
die "SQL has " . scalar(@replacements) . " parameters but " . scalar(@params) . " were given\n";
}
# Set the index mark to match the size of the @params for iterating through the replacements
Analizo
view release on metacpan or search on metacpan
lib/Analizo/Command.pm view on Meta::CPAN
options to every analizo tool:
analizo <tool> --help
analizo <tool> --usage
Any analizo tool should implement B<validate()>, method which is called by
B<validate_args()> implemented here. See L<App::Cmd::Command> for details about
B<validate_args()>.
=cut
sub validate_args {
my ($self, $opt, $args) = @_;
if ($self->app->global_options->version) {
$self->usage_error("Invalid option: --version");
}
elsif ($self->app->global_options->usage) {
print $self->app->usage, "\n", $self->usage;
exit 0;
}
$self->validate($opt, $args);
}
sub version_information {
my ($self) = @_;
sprintf("%s version %s", $self->app->arg0, $Analizo::VERSION);
Anansi-Component
view release on metacpan or search on metacpan
lib/Anansi/Component.pm view on Meta::CPAN
package Anansi::ComponentManagerExample::ComponentExample;
use base qw(Anansi::Component);
sub validate {
return 1;
}
sub doSomething {
my ($self, $channel, %parameters) = @_;
}
Anansi::Component::addChannel(
'Anansi::ComponentManagerExample::ComponentExample',
'VALIDATE_AS_APPROPRIATE' => Anansi::ComponentManagerExample::ComponentExample->validate
);
Anansi::Component::addChannel(
'Anansi::ComponentManagerExample::ComponentExample',
'SOME_COMPONENT_CHANNEL' => Anansi::ComponentManagerExample::ComponentExample->doSomething
);
Anansi-ComponentManager
view release on metacpan or search on metacpan
lib/Anansi/ComponentManager.pm view on Meta::CPAN
'Anansi::ComponentManagerExample::AndSoOnComponentExample' => -1,
};
return $PRIORITY;
}
sub validate {
my ($self, $channel, %parameters) = @_;
return 1;
}
sub doSomething {
lib/Anansi/ComponentManager.pm view on Meta::CPAN
'Anansi::ComponentManagerExample::ComponentExample',
'PRIORITY_OF_VALIDATE' => Anansi::ComponentManagerExample::ComponentExample->priority
);
Anansi::Component::addChannel(
'Anansi::ComponentManagerExample::ComponentExample',
'VALIDATE_AS_APPROPRIATE' => Anansi::ComponentManagerExample::ComponentExample->validate
);
Anansi::Component::addChannel(
'Anansi::ComponentManagerExample::ComponentExample',
'SOME_COMPONENT_CHANNEL' => Anansi::ComponentManagerExample::ComponentExample->doSomething
);
lib/Anansi/ComponentManager.pm view on Meta::CPAN
the implementer of the component manager. A unique identifier for the object
may either be supplied or automatically generated and is returned as a means of
referencing the object.
Note: The process of selecting the component to use requires each component to
validate it's own appropriateness. Therefore this process makes use of a
VALIDATE_AS_APPROPRIATE component channel which is expected to return either a
B<1> I<(one)> or a B<0> I<(zero)> representing B<appropriate> or
B<inappropriate>. If this component channel does not exist it is assumed that
the component is not designed to be implemented in this way. A component may
also provide a PRIORITY_OF_VALIDATE component channel to aid in validating where
Anansi-Database-MySQL
view release on metacpan or search on metacpan
lib/Anansi/Database/MySQL.pm view on Meta::CPAN
Anansi::Database::MySQL - A manager for MySQL databases.
=head1 SYNOPSIS
use Anansi::Database::MySQL;
if(Anansi::Database::MySQL->validate(
undef,
DRIVER => 'MySQL',
)) {
my $OBJECT = Anansi::Database::MySQL->new();
if($OBJECT->connect(
lib/Anansi/Database/MySQL.pm view on Meta::CPAN
Anansi::Component::addChannel('Anansi::Database::MySQL', 'STATEMENT' => 'Anansi::DatabaseComponent::statement');
=head3 validate
See L<Anansi::DatabaseComponent::validate|Anansi::DatabaseComponent/"validate"> for details. Overridden by L<Anansi::Database::MySQL::validate|Anansi::Database::MySQL/"validate">.
=cut
=head2 connect
lib/Anansi/Database/MySQL.pm view on Meta::CPAN
Anansi::Component::addChannel('Anansi::Database::MySQL', 'CONNECT' => 'connect');
=head2 validate
if(1 == Anansi::Database::MySQL::validate($OBJECT, undef));
if(1 == Anansi::Database::MySQL::channel($OBJECT, 'VALIDATE_AS_APPROPRIATE'));
if(1 == Anansi::Database::MySQL->validate(undef));
if(1 == Anansi::Database::MySQL->channel('VALIDATE_AS_APPROPRIATE'));
if(1 == $OBJECT->validate(undef, DRIVER => 'MySQL'));
if(1 == $OBJECT->channel('VALIDATE_AS_APPROPRIATE', DRIVER => 'MySQL'));
if(1 == Anansi::Database::MySQL->validate(undef, DRIVER => 'MySQL'));
if(1 == Anansi::Database::MySQL->channel('VALIDATE_AS_APPROPRIATE', DRIVER => 'MySQL'));
=over 4
lib/Anansi/Database/MySQL.pm view on Meta::CPAN
=back
=back
Overrides L<Anansi::DatabaseComponent::validate|Anansi::DatabaseComponent/"validate">.
=cut
sub validate {
my ($self, $channel, %parameters) = @_;
$parameters{DRIVERS} = 'MySQL';
return $self->SUPER::validate(undef, (%parameters));
}
Anansi::Component::addChannel('Anansi::Database::MySQL', 'VALIDATE_AS_APPROPRIATE' => 'validate');
=head1 NOTES
This module is designed to make it simple, easy and quite fast to code your
Anansi-Database-Oracle
view release on metacpan or search on metacpan
lib/Anansi/Database/Oracle.pm view on Meta::CPAN
Anansi::Database::Oracle - A manager for Oracle databases.
=head1 SYNOPSIS
use Anansi::Database::Oracle;
if(Anansi::Database::Oracle->validate(
undef,
DRIVER => 'Oracle',
)) {
my $OBJECT = Anansi::Database::Oracle->new();
if($OBJECT->connect(
lib/Anansi/Database/Oracle.pm view on Meta::CPAN
Anansi::Component::addChannel('Anansi::Database::Oracle', 'STATEMENT' => 'Anansi::DatabaseComponent::statement');
=head3 validate
See L<Anansi::DatabaseComponent::validate|Anansi::DatabaseComponent/"validate"> for details. Overridden by L<Anansi::Database::Oracle::validate|Anansi::Database::Oracle/"validate">.
=cut
=head2 connect
lib/Anansi/Database/Oracle.pm view on Meta::CPAN
}
Anansi::Component::addChannel('Anansi::Database::Oracle', 'CONNECT' => 'connect');
=head2 validate
if(1 == Anansi::Database::Oracle::validate($OBJECT, undef));
if(1 == Anansi::Database::Oracle::channel($OBJECT, 'VALIDATE_AS_APPROPRIATE'));
if(1 == Anansi::Database::Oracle->validate(undef));
if(1 == Anansi::Database::Oracle->channel('VALIDATE_AS_APPROPRIATE'));
if(1 == $OBJECT->validate(undef, DRIVER => 'Oracle'));
if(1 == $OBJECT->channel('VALIDATE_AS_APPROPRIATE', DRIVER => 'Oracle'));
if(1 == Anansi::Database::Oracle->validate(undef, DRIVER => 'Oracle'));
if(1 == Anansi::Database::Oracle->channel('VALIDATE_AS_APPROPRIATE', DRIVER => 'Oracle'));
=over 4
lib/Anansi/Database/Oracle.pm view on Meta::CPAN
=back
=back
Overrides L<Anansi::DatabaseComponent::validate|Anansi::DatabaseComponent/"validate">.
=cut
sub validate {
my ($self, $channel, %parameters) = @_;
$parameters{DRIVERS} = 'Oracle';
return $self->SUPER::validate(undef, (%parameters));
}
Anansi::Component::addChannel('Anansi::Database::Oracle', 'VALIDATE_AS_APPROPRIATE' => 'validate');
=head1 NOTES
This module is designed to make it simple, easy and quite fast to code your
Anansi-Database-PostgreSQL
view release on metacpan or search on metacpan
lib/Anansi/Database/PostgreSQL.pm view on Meta::CPAN
Anansi::Database::PostgreSQL - A manager for PostgreSQL databases.
=head1 SYNOPSIS
use Anansi::Database::PostgreSQL;
if(Anansi::Database::PostgreSQL->validate(
undef,
DRIVER => 'PostgreSQL',
)) {
my $OBJECT = Anansi::Database::PostgreSQL->new();
if($OBJECT->connect(
lib/Anansi/Database/PostgreSQL.pm view on Meta::CPAN
Anansi::Component::addChannel('Anansi::Database::PostgreSQL', 'STATEMENT' => 'Anansi::DatabaseComponent::statement');
=head3 validate
See L<Anansi::DatabaseComponent::validate|Anansi::DatabaseComponent/"validate"> for details. Overridden by L<Anansi::Database::PostgreSQL::validate|Anansi::Database::PostgreSQL/"validate">.
=cut
=head2 connect
lib/Anansi/Database/PostgreSQL.pm view on Meta::CPAN
}
Anansi::Component::addChannel('Anansi::Database::PostgreSQL', 'CONNECT' => 'connect');
=head2 validate
if(1 == Anansi::Database::PostgreSQL::validate($OBJECT, undef));
if(1 == Anansi::Database::PostgreSQL::channel($OBJECT, 'VALIDATE_AS_APPROPRIATE'));
if(1 == Anansi::Database::PostgreSQL->validate(undef));
if(1 == Anansi::Database::PostgreSQL->channel('VALIDATE_AS_APPROPRIATE'));
if(1 == $OBJECT->validate(undef, DRIVER => 'PostgreSQL'));
if(1 == $OBJECT->channel('VALIDATE_AS_APPROPRIATE', DRIVER => 'PostgreSQL'));
if(1 == Anansi::Database::PostgreSQL->validate(undef, DRIVER => 'PostgreSQL'));
if(1 == Anansi::Database::PostgreSQL->channel('VALIDATE_AS_APPROPRIATE', DRIVER => 'PostgreSQL'));
=over 4
lib/Anansi/Database/PostgreSQL.pm view on Meta::CPAN
=back
=back
Overrides L<Anansi::DatabaseComponent::validate|Anansi::DatabaseComponent/"validate">.
=cut
sub validate {
my ($self, $channel, %parameters) = @_;
$parameters{DRIVERS} = [
'Pg',
'Postgres',
'PostgreSQL'
];
return $self->SUPER::validate(undef, (%parameters));
}
Anansi::Component::addChannel('Anansi::Database::PostgreSQL', 'VALIDATE_AS_APPROPRIATE' => 'validate');
=head1 NOTES
This module is designed to make it simple, easy and quite fast to code your
Anansi-DatabaseComponent
view release on metacpan or search on metacpan
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
],
(%parameters),
);
}
sub validate {
my ($self, $channel, %parameters) = @_;
$parameters{DRIVER} = 'Example';
return Anansi::DatabaseComponent::validate(undef, %parameters);
}
Anansi::DatabaseComponent::addChannel('Anansi::Database::Example', 'AUTOCOMMIT' => 'Anansi::DatabaseComponent::autocommit');
Anansi::DatabaseComponent::addChannel('Anansi::Database::Example', 'COMMIT' => 'Anansi::DatabaseComponent::commit');
Anansi::DatabaseComponent::addChannel('Anansi::Database::Example', 'CONNECT' => 'connect');
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
Anansi::DatabaseComponent::addChannel('Anansi::Database::Example', 'FINISH' => 'Anansi::DatabaseComponent::finish');
Anansi::DatabaseComponent::addChannel('Anansi::Database::Example', 'HANDLE' => 'Anansi::DatabaseComponent::handle');
Anansi::DatabaseComponent::addChannel('Anansi::Database::Example', 'PREPARE' => 'Anansi::DatabaseComponent::prepare');
Anansi::DatabaseComponent::addChannel('Anansi::Database::Example', 'ROLLBACK' => 'Anansi::DatabaseComponent::rollback');
Anansi::DatabaseComponent::addChannel('Anansi::Database::Example', 'STATEMENT' => 'Anansi::DatabaseComponent::statement');
Anansi::DatabaseComponent::addChannel('Anansi::Database::Example', 'VALIDATE_AS_APPROPRIATE' => 'validate');
1;
package main;
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
=back
Verifies that the supplied parameters are all hashes and that they each contain
a I<NAME> key with a string value. Returns B<1> I<(one)> when validity is
confirmed and B<0> I<(zero)> when an invalid structure is determined. Used to
validate the I<INPUT> parameter of the B<bind> method.
=cut
sub binding {
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
The name of the parameter that contains the value to use.
=item REF I<(Array B<or> String, Optional)>
The data types used to validate the value to use.
=back
=back
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
}
Anansi::DatabaseComponent::addChannel('Anansi::DatabaseComponent', 'STATEMENT' => 'statement');
=head2 validate
if(1 == Anansi::DatabaseComponent::validate($OBJECT, undef));
if(1 == Anansi::DatabaseComponent::channel($OBJECT, 'VALIDATE_AS_APPROPRIATE'));
if(1 == Anansi::DatabaseComponent->validate(undef, DRIVERS => ['some::driver::module', 'anotherDriver']));
if(1 == Anansi::DatabaseComponent->channel('VALIDATE_AS_APPROPRIATE'));
if(1 == $OBJECT->validate(undef, DRIVER => 'Example'));
if(1 == $OBJECT->channel('VALIDATE_AS_APPROPRIATE', DRIVER => 'Example'));
if(1 == Anansi::DatabaseComponent->validate(undef, DRIVER => 'Example', DRIVERS => 'some::driver'));
if(1 == Anansi::DatabaseComponent->channel('VALIDATE_AS_APPROPRIATE', DRIVER => 'Example'));
=over 4
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
supplied. Returns B<1> I<(one)> for valid and B<0> I<(zero)> for invalid.
=cut
sub validate {
my ($self, $channel, %parameters) = @_;
my $package = $self;
$package = ref($self) if(ref($self) !~ /^$/);
my %modules = Anansi::Actor->modules();
return 0 if(!defined($modules{'Bundle::DBI'}));
lib/Anansi/DatabaseComponent.pm view on Meta::CPAN
}
}
return 1;
}
Anansi::DatabaseComponent::addChannel('Anansi::DatabaseComponent', 'VALIDATE_AS_APPROPRIATE' => 'validate');
=head1 NOTES
This module is designed to make it simple, easy and quite fast to code your
Anansi-Script-CGI
view release on metacpan or search on metacpan
lib/Anansi/Script/CGI.pm view on Meta::CPAN
}
print "\n";
}
=head2 validate
my $valid = $OBJECT->validate();
my $valid = $OBJECT->channel('VALIDATE_AS_APPROPRIATE');
Determines whether this module is the correct one to use for handling Perl
script execution.
=cut
sub validate {
my $self = shift(@_);
my $channel;
$channel = shift(@_) if(0 < scalar(@_));
return 1 if(exists($ENV{'MOD_PERL'}));
return 1 if(exists($ENV{'GATEWAY_INTERFACE'}));
return 0;
}
Anansi::ScriptComponent::addChannel('Anansi::Script::CGI', 'VALIDATE_AS_APPROPRIATE' => 'validate');
=head1 NOTES
This module is designed to make it simple, easy and quite fast to code your
Anansi-Script-JSON
view release on metacpan or search on metacpan
lib/Anansi/Script/JSON.pm view on Meta::CPAN
}
Anansi::ScriptComponent::addChannel('Anansi::Script::JSON', 'PRIORITY_OF_VALIDATE' => 'priority');
=head2 validate
my $valid = $OBJECT->validate();
my $valid = $OBJECT->channel('VALIDATE_AS_APPROPRIATE');
Determines whether this module is the correct one to use for handling Perl
script execution.
=cut
sub validate {
my ($self, %parameters) = @_;
my $channel;
$channel = shift(@_) if(0 < scalar(@_));
return 0 if(!defined($ENV{'HTTP_HOST'}));
my $CGI = CGI->new();
return 0 if(!defined($CGI->http('Content-Type')));
return 0 if($CGI->http('Content-Type') !~ /^application\/json(request|-rpc)?(;.*)?$/i);
return 1;
}
Anansi::ScriptComponent::addChannel('Anansi::Script::JSON', 'VALIDATE_AS_APPROPRIATE' => 'validate');
=head1 NOTES
This module is designed to make it simple, easy and quite fast to code your
Anansi-Script-SOAP
view release on metacpan or search on metacpan
lib/Anansi/Script/SOAP.pm view on Meta::CPAN
}
Anansi::ScriptComponent::addChannel('Anansi::Script::SOAP', 'PRIORITY_OF_VALIDATE' => 'priority');
=head2 validate
my $valid = $OBJECT->validate();
my $valid = $OBJECT->channel('VALIDATE_AS_APPROPRIATE');
Determines whether this module is the correct one to use for handling Perl
script execution.
=cut
sub validate {
my ($self, %parameters) = @_;
my $channel;
$channel = shift(@_) if(0 < scalar(@_));
return 0 if(!defined($ENV{'HTTP_HOST'}));
my $CGI = CGI->new();
lib/Anansi/Script/SOAP.pm view on Meta::CPAN
return 0 if(!defined($CGI->http('Content-Type')));
return 0 if($CGI->http('Content-Type') !~ /^application\/soap\+xml(;.*)?$/i);
return 1;
}
Anansi::ScriptComponent::addChannel('Anansi::Script::SOAP', 'VALIDATE_AS_APPROPRIATE' => 'validate');
=head1 NOTES
This module is designed to make it simple, easy and quite fast to code your
Anansi-Script-Shell
view release on metacpan or search on metacpan
lib/Anansi/Script/Shell.pm view on Meta::CPAN
}
Anansi::ScriptComponent::addChannel('Anansi::Script::Shell', 'PARAMETER' => 'parameter');
=head2 validate
my $valid = $OBJECT->validate();
my $valid = $OBJECT->channel('VALIDATE_AS_APPROPRIATE');
Determines whether this module is the correct one to use for handling Perl
script execution.
=cut
sub validate {
my $self = shift(@_);
my $channel;
$channel = shift(@_) if(0 < scalar(@_));
return 1;
}
Anansi::ScriptComponent::addChannel('Anansi::Script::Shell', 'VALIDATE_AS_APPROPRIATE' => 'validate');
=head1 NOTES
This module is designed to make it simple, easy and quite fast to code your
Anansi-Script-XML
view release on metacpan or search on metacpan
lib/Anansi/Script/XML.pm view on Meta::CPAN
}
Anansi::ScriptComponent::addChannel('Anansi::Script::XML', 'PRIORITY_OF_VALIDATE' => 'priority');
=head2 validate
my $valid = $OBJECT->validate();
my $valid = $OBJECT->channel('VALIDATE_AS_APPROPRIATE');
Determines whether this module is the correct one to use for handling Perl
script execution.
=cut
sub validate {
my ($self, %parameters) = @_;
my $channel;
$channel = shift(@_) if(0 < scalar(@_));
return 0 if(!defined($ENV{'HTTP_HOST'}));
my $CGI = CGI->new();
return 0 if(!defined($CGI->http('Content-Type')));
return 0 if($CGI->http('Content-Type') !~ /^(application|text)?\/xml(;.*)?$/i);
return 1;
}
Anansi::ScriptComponent::addChannel('Anansi::Script::XML', 'VALIDATE_AS_APPROPRIATE' => 'validate');
=head1 NOTES
This module is designed to make it simple, easy and quite fast to code your
Anansi-ScriptComponent
view release on metacpan or search on metacpan
lib/Anansi/ScriptComponent.pm view on Meta::CPAN
package Anansi::Script::Example;
use base qw(Anansi::ScriptComponent);
sub validate {
my ($self, $channel, %parameters) = @_;
return $self->SUPER::validate(undef);
}
Anansi::ScriptComponent::addChannel('Anansi::Script::Example', 'VALIDATE_AS_APPROPRIATE' => 'validate');
1;
=head1 DESCRIPTION
lib/Anansi/ScriptComponent.pm view on Meta::CPAN
=head1 METHODS
=cut
=head2 validate
if(1 == Anansi::ScriptComponent::validate($OBJECT, undef));
if(1 == Anansi::ScriptComponent::channel($OBJECT, 'VALIDATE_AS_APPROPRIATE'));
if(1 == Anansi::ScriptComponent->validate(undef));
if(1 == Anansi::ScriptComponent->channel('VALIDATE_AS_APPROPRIATE'));
if(1 == $OBJECT->validate(undef));
if(1 == $OBJECT->channel('VALIDATE_AS_APPROPRIATE'));
=over 4
lib/Anansi/ScriptComponent.pm view on Meta::CPAN
Returns B<1> I<(one)> for yes and B<0> I<(zero)> for no.
=cut
sub validate {
my ($self, $channel, %parameters) = @_;
my $package = $self;
$package = ref($self) if(ref($self) !~ /^$/);
return 1;
}
Anansi::Component::addChannel('Anansi::ScriptComponent', 'VALIDATE_AS_APPROPRIATE' => 'validate');
=head1 METHODS
=cut
Ancient
view release on metacpan or search on metacpan
lib/object.pm view on Meta::CPAN
=over 4
=item * C<name> - Type name (e.g., "PositiveInt", "Email")
=item * C<check> - C function to validate values (required)
=item * C<coerce> - C function to coerce values (optional, pass NULL)
=back
( run in 2.002 seconds using v1.01-cache-2.11-cpan-d01c6094234 )