view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
sub _version ($) {
my $s = shift || 0;
$s =~ s/^(\d+)\.?//;
my $l = $1 || 0;
my @v = map { $_ . '0' x (3 - length $_) } $s =~ /(\d{1,3})\D?/g;
$l = $l . '.' . join '', @v if @v;
return $l + 0;
}
# Cloned from Params::Util::_CLASS
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
sub _version ($) {
my $s = shift || 0;
$s =~ s/^(\d+)\.?//;
my $l = $1 || 0;
my @v = map { $_ . '0' x (3 - length $_) } $s =~ /(\d{1,3})\D?/g;
$l = $l . '.' . join '', @v if @v;
return $l + 0;
}
# Cloned from Params::Util::_CLASS
view release on metacpan or search on metacpan
lib/AVLTree.pm view on Meta::CPAN
# Instantiate a tree which holds numbers
my $tree = AVLTree->new(\&cmp_f);
# Add some numbers to the tree
map { $tree->insert($_) } qw/10 20 30 40 50 25/;
# Now invoke some useful methods
# Size of the tree
printf "Size of the tree: %d\n", $tree->size();
view release on metacpan or search on metacpan
lib/AWS/CLIWrapper.pm view on Meta::CPAN
return $v;
} else {
push @v, $v;
}
} elsif ($type eq 'ARRAY') {
push @v, map { ref($_) ? encode_json(_compat_kv($_)) : $_ } @$v;
} elsif ($type eq 'HASH') {
push @v, encode_json(_compat_kv($v));
} elsif ($type eq 'AWS::CLIWrapper::Boolean') {
if ($$v == 1) {
return ($k);
lib/AWS/CLIWrapper.pm view on Meta::CPAN
while (my($k, $v) = each %$param) {
my @o = param2opt($k, $v);
if ($service eq 's3' && $k =~ /^(?:include|exclude)$/) {
my $optk = shift @o;
@o = map { $optk => $_ } @o;
}
push @cmd, @o;
}
@cmd = map { shell_quote($_) } @cmd;
warn "cmd: ".join(' ', @cmd) if $ENV{AWSCLI_DEBUG};
my $error_re = $self->catch_error_pattern;
my $retries = $error_re ? $self->catch_error_retries : 0;
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
sub _version ($) {
my $s = shift || 0;
$s =~ s/^(\d+)\.?//;
my $l = $1 || 0;
my @v = map { $_ . '0' x (3 - length $_) } $s =~ /(\d{1,3})\D?/g;
$l = $l . '.' . join '', @v if @v;
return $l + 0;
}
# Cloned from Params::Util::_CLASS
view release on metacpan or search on metacpan
lib/AWS/IP.pm view on Meta::CPAN
my $ip_ranges;
if ($service)
{
$ip_ranges = Net::CIDR::Set->new( map { $_->{ip_prefix} } grep { $_->{service} eq $service } @{$self->get_raw_data->{prefixes}});
}
else
{
$ip_ranges = Net::CIDR::Set->new( map { $_->{ip_prefix} } @{$self->get_raw_data->{prefixes}} );
}
$ip_ranges->contains($ip);
}
lib/AWS/IP.pm view on Meta::CPAN
=cut
sub get_cidrs
{
my ($self) = @_;
[ map { $_->{ip_prefix} } @{$self->get_raw_data->{prefixes}} ];
}
=head2 get_cidrs_by_region ($region)
Returns an arrayref of CIDRs matching the provided region.
lib/AWS/IP.pm view on Meta::CPAN
sub get_cidrs_by_region
{
my ($self, $region) = @_;
croak 'Error must provide region' unless $region;
[ map { $_->{ip_prefix} } grep { $_->{region} eq $region } @{$self->get_raw_data->{prefixes}} ];
}
=head2 get_cidrs_by_service ($service)
Returns an arrayref of CIDRs matching the provided service (AMAZON|EC2|CLOUDFRONT|ROUTE53|ROUTE53_HEALTHCHECKS).
lib/AWS/IP.pm view on Meta::CPAN
sub get_cidrs_by_service
{
my ($self, $service) = @_;
croak 'Error must provide service' unless $service;
[ map { $_->{ip_prefix} } grep { $_->{service} eq $service } @{$self->get_raw_data->{prefixes}} ];
}
=head2 get_regions
Returns an arrayref of the regions in the AWS IP address data.
view release on metacpan or search on metacpan
CONTRIBUTING.md view on Meta::CPAN
If you send a patch or pull request, your name and email address will be
included in the documentation as a contributor (using the attribution on the
commit or patch), unless you specifically request for it not to be. If you
wish to be listed under a different name or address, you should submit a pull
request to the .mailmap file to contain the correct mapping.
[Check here](https://github.com/git/git/blob/master/Documentation/mailmap.txt)
for more information on git's .mailmap files.
This file was generated via Dist::Zilla::Plugin::GenerateFile::FromShareDir 0.014 from a
template file originating in Dist-Zilla-PluginBundle-MAXMIND-0.83.
view release on metacpan or search on metacpan
author/publish-perl-runtimes.pl view on Meta::CPAN
$arch_suffix //= "-$arch";
my $pm = Parallel::ForkManager->new(10);
my $regions = do {
open my $fh, '<', "$FindBin::Bin/regions-$arch.txt" or die "$!";
my @regions = sort { $a cmp $b } map { chomp; $_; } <$fh>;
close($fh);
\@regions;
};
for my $zip(glob "$FindBin::Bin/../.perl-layer/dist/perl-*-$suffix-$arch.zip") {
view release on metacpan or search on metacpan
lib/AWS/Networks.pm view on Meta::CPAN
is => 'ro',
isa => 'ArrayRef',
default => sub {
my ($self) = @_;
my $regions = {};
map { $regions->{ $_->{ region } } = 1 } @{ $self->networks };
return [ keys %$regions ];
},
lazy => 1,
);
lib/AWS/Networks.pm view on Meta::CPAN
is => 'ro',
isa => 'ArrayRef',
default => sub {
my ($self) = @_;
my $services = {};
map { $services->{ $_->{ service } } = 1 } @{ $self->networks };
return [ keys %$services ];
},
lazy => 1,
);
lib/AWS/Networks.pm view on Meta::CPAN
has cidrs => (
is => 'ro',
isa => 'ArrayRef',
default => sub {
my ($self) = @_;
return [ map { $_->{ ip_prefix } } @{ $self->networks } ];
},
lazy => 1,
);
1;
view release on metacpan or search on metacpan
lib/AWS/S3.pm view on Meta::CPAN
creation_date => $node->getElementsByLocalName('CreationDate')->string_value,
s3 => $s,
);
} # end foreach()
$LOG->debug('Listed AWS buckets', { buckets => [map $_->name, @buckets] });
return @buckets;
} # end buckets()
sub bucket {
my ( $s, $name ) = @_;
lib/AWS/S3.pm view on Meta::CPAN
# You can't delete a bucket until it's empty.
# Empty a bucket like this:
while( my @files = $iterator->next_page )
{
map { $_->delete } @files;
# Return to page 1:
$iterator->page_number( 1 );
}# end while()
view release on metacpan or search on metacpan
lib/AWS/SQS/Simple.pm view on Meta::CPAN
my $octets = encode( 'utf-8-strict', $params->{ $key } ) ;
$params->{ $key } = escape( $octets ) ;
}
my $uri_str = join('&', map { $_ . '=' . $params->{$_} } keys %$params ) ;
my $sign_str = "GET\n".$self->{ END_POINT }."\n/" ;
$sign_str .= $url_additional_str . "/" if( $params->{ Action } ne "CreateQueue" ) ;
$sign_str .= "\n" . $sign_query ;
view release on metacpan or search on metacpan
lib/AWS/Signature/V2.pm view on Meta::CPAN
sub _build_aws_access_key { $ENV{AWS_ACCESS_KEY} }
sub _build_aws_secret_key { $ENV{AWS_SECRET_KEY} }
sub sign {
my ($self, $url) = @_;
my %eq = map { split /=/, $_ } split /&/, $url->query();
my %q = map { $_ => decode_utf8( uri_unescape( $eq{$_} ) ) } keys %eq;
$q{Keywords} =~ s/\+/ /g if $q{Keywords};
$q{AWSAccessKeyId} = $self->aws_access_key;
$q{Timestamp} ||= do {
my ( $ss, $mm, $hh, $dd, $mo, $yy ) = gmtime();
join '',
sprintf( '%04d-%02d-%02d', $yy + 1900, $mo + 1, $dd ), 'T',
sprintf( '%02d:%02d:%02d', $hh, $mm, $ss ), 'Z';
};
$q{Version} ||= '2010-09-01';
my $sq = join '&',
map { $_ . '=' . uri_escape_utf8( $q{$_}, "^A-Za-z0-9\-_.~" ) }
sort keys %q;
my $tosign = join "\n", 'GET', $url->host, $url->path, $sq;
my $signature = hmac_sha256_base64( $tosign, $self->aws_secret_key );
$signature .= '=' while length($signature) % 4; # padding required
$q{Signature} = $signature;
lib/AWS/Signature/V2.pm view on Meta::CPAN
$url;
}
sub signature {
my ($self, $url) = @_;
my %eq = map { split /=/, $_ } split /&/, $url->query();
my %q = map { $_ => uri_unescape( $eq{$_} ) } keys %eq;
$q{Signature};
}
1;
view release on metacpan or search on metacpan
lib/AWS/Signature4.pm view on Meta::CPAN
while (my ($key,$value) = splice(@params,0,2)) {
$key = uri_escape($key);
$value = uri_escape($value);
push @{$canonical{$key}},$value;
}
my $canonical_query_string = join '&',map {my $key = $_; map {"$key=$_"} sort @{$canonical{$key}}} sort keys %canonical;
# canonicalize the request headers
my (@canonical,%signed_fields);
for my $header (sort map {lc} $headers->header_field_names) {
next if $header =~ /^date$/i;
my @values = $headers->header($header);
# remove redundant whitespace
foreach (@values ) {
next if /^".+"$/;
lib/AWS/Signature4.pm view on Meta::CPAN
push @canonical,"$header:".join(',',@values);
$signed_fields{$header}++;
}
my $canonical_headers = join "\n",@canonical;
$canonical_headers .= "\n";
my $signed_headers = join ';',sort map {lc} keys %signed_fields;
my $canonical_request = join("\n",$method,$path,$canonical_query_string,
$canonical_headers,$signed_headers,$hashed_payload);
my $request_digest = sha256_hex($canonical_request);
view release on metacpan or search on metacpan
sub segments {
return unless $buf;
$buf =~ s/{"format":"json","version":1}//g;
my @seg = split /\n/, $buf;
shift @seg; # despose first ""
return map { decode_json($_) } @seg;
}
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# Normalise multipart versions
$s =~ s/(\.)(\d{1,3})/sprintf("$1%03d",$2)/eg;
}
$s =~ s/^(\d+)\.?//;
my $l = $1 || 0;
my @v = map {
$_ . '0' x (3 - length $_)
} $s =~ /(\d{1,3})\D?/g;
$l = $l . '.' . join '', @v if @v;
return $l + 0;
}
view release on metacpan or search on metacpan
lib/Aard.pm view on Meta::CPAN
[index1_item_format => 'Z4' , 4 ],
[key_length_format => 'Z2' , 2 ],
[article_length_format => 'Z2' , 2 ],
];
my $header_length = sum map { $_->[2] } @{HEADER_SPEC()};
sub decompress {
my ($input) = @_;
my $output = $input;
inflate \$input => \$output;
view release on metacpan or search on metacpan
lib/Abilities.pm view on Meta::CPAN
sub does_role {
my ($self, $role) = @_;
return unless $role;
foreach (map([$_, $self->get_role($_)], $self->roles)) {
return 1 if $_->[0] eq $role || $_->[1]->does_role($role);
}
return;
}
lib/Abilities.pm view on Meta::CPAN
carp "Can't handle action of reference ".ref($_);
}
}
# load actions from roles this user/role consumes
my @hashes = map { $self->get_role($_)->abilities } $self->roles;
# merge all abilities
while (scalar @hashes) {
$abilities = merge($abilities, shift @hashes);
}
view release on metacpan or search on metacpan
lib/Abstract/Meta/Attribute/Method.pm view on Meta::CPAN
sub index_association_data {
my ($data, $attr_name, $index) = @_;
return $data if ref($data) eq 'HASH';
my %result;
if($index && $$data[0]->can($index)) {
%result = (map {($_->$index, $_)} @$data);
} else {
%result = (map {($_ . "", $_)} @$data);
}
\%result;
}
view release on metacpan or search on metacpan
my @r;
foreach (split "\n",$r) {
next if m!^//!;
next if m!^\0!;
my ($class,$id) = Ace->split($_);
my @objects = map { $self->class_for($class,$id)->new(Ace->split($_),$self,1)} split "\t";
push @r,\@objects;
}
return @r;
}
$db = Ace->connect(-host => $host,
-port => $port,
-path => $database_path,
-program => $local_connection_program
-classmapper => $object_class,
-timeout => $timeout,
-query_timeout => $query_timeout
-cache => {cache parameters},
);
$db = Ace->connect(-host => 'beta.crbm.cnrs-mop.fr',
-port => 20000100,
-program=>'aceclient');
=item B<-classmapper>
The optional B<-classmapper> argument (alias B<-class>) points to the
class you would like to return from database queries. It is provided
for your use if you subclass Ace::Object. For example, if you have
created a subclass of Ace::Object called Ace::Object::Graphics, you
can have the database return this subclass by default by connecting
this way:
view release on metacpan or search on metacpan
fortune/jackbauer view on Meta::CPAN
%
Jack Bauer did not cry when he saw President Palmer's dead body...water was pooling on his face to block radioactive material.
%
We hold these truths to be self evident, that all men are not created equal to Jack Bauer.
%
Jack Bauer doesn't need a map. All roads lead to Jack Bauer.
%
Jack Bauer doesn't contemplate suicide, he just does it. Every season.
%
Most pilots need 5,000 feet of runway to land a plane. Jack Bauer needs 100 feet and a gun.
%
view release on metacpan or search on metacpan
inc/MyBuilder.pm view on Meta::CPAN
sub ACTION_tidy {
my $self = shift;
my @extra = qw( Build.PL );
my %found_files = map { %$_ } $self->find_pm_files,
$self->_find_file_by_type( 'pm', 't' ),
$self->_find_file_by_type( 'pm', 'inc' ),
$self->_find_file_by_type( 't', 't' );
my @files = ( keys %found_files,
map { $self->localize_file_path( $_ ) } @extra );
for my $file ( @files ) {
system 'perltidy', '-b', $file;
unlink "$file.bak" if $? == 0;
}
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
sub _version ($) {
my $s = shift || 0;
$s =~ s/^(\d+)\.?//;
my $l = $1 || 0;
my @v = map { $_ . '0' x (3 - length $_) } $s =~ /(\d{1,3})\D?/g;
$l = $l . '.' . join '', @v if @v;
return $l + 0;
}
# Cloned from Params::Util::_CLASS
view release on metacpan or search on metacpan
q => "What's the scariest thing you've ever done?",
a => ['say I love you', 'meet the in-laws'] },
];
# Set you to a purposfully strict set of answers
my $you = [ map { [ $_->{a}[0], $_->{a}[0], 'mandatory' ] } sort { $a->{i} <=> $b->{i} } @$questions ];
my %answers = (); # Bucket for the indexed "me" answers
my $affinity = Acme::Affinity->new;
}
Term::Clear::clear();
# Sorted me answers
my $me = [ map { $answers{$_} } sort { $a <=> $b } keys %answers ];
$affinity = Acme::Affinity->new(
questions => [ map { { $_->{q} => $_->{a} } } @$questions ],
me => $me,
you => $you,
);
print 'Score: ', $affinity->score, "\n";
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# Normalise multipart versions
$s =~ s/(\.)(\d{1,3})/sprintf("$1%03d",$2)/eg;
}
$s =~ s/^(\d+)\.?//;
my $l = $1 || 0;
my @v = map {
$_ . '0' x (3 - length $_)
} $s =~ /(\d{1,3})\D?/g;
$l = $l . '.' . join '', @v if @v;
return $l + 0;
}
view release on metacpan or search on metacpan
lib/Acme/AjiFry/EN.pm view on Meta::CPAN
my $translated_word;
while ($ajifry_word) {
my $match = 0;
my $map = MAP;
foreach my $key ( keys %{$map} ) {
if ( $ajifry_word =~ s/^$map->{$key}// ) {
$match = 1;
if ( $key eq 'space' ) {
$translated_word .= ' ';
}
else {
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
# Normalise multipart versions
$s =~ s/(\.)(\d{1,3})/sprintf("$1%03d",$2)/eg;
}
$s =~ s/^(\d+)\.?//;
my $l = $1 || 0;
my @v = map {
$_ . '0' x (3 - length $_)
} $s =~ /(\d{1,3})\D?/g;
$l = $l . '.' . join '', @v if @v;
return $l + 0;
}
view release on metacpan or search on metacpan
lib/Acme/AlgebraicToRPN.pm view on Meta::CPAN
$.parser = Math::Symbolic::Parser->new;
$.Class = $class;
if (defined $.userFunc) {
my @uf = @{$.userFunc};
my %uf;
map { $uf{$_} = 1 } @uf;
$.userFunc = \%uf;
my %x;
map {
my $proc = $_;
$x{$_} = sub {
my $argumentstring = shift;
return Math::Symbolic::Constant->new(
qq($proc($argumentstring))
lib/Acme/AlgebraicToRPN.pm view on Meta::CPAN
}
sub _Cleanup {
my ($self) = @_;
my @Stack;
map {
$_ =~ s/^,//;
if ($_ ne '') {
my (@c) = split(',', $_);
if (@c) {
s/\s//g foreach @c;
lib/Acme/AlgebraicToRPN.pm view on Meta::CPAN
sub check {
my ($self, $ref, @result) = @_;
my @shouldbe = @$ref;
return 0 unless @shouldbe == @result;
my $same = 1;
map {
my $sb = shift(@shouldbe);
$same = 0 unless $sb eq $_;
} @result;
return $same;
}
view release on metacpan or search on metacpan
Makefile.PL view on Meta::CPAN
BEGIN {
use strict; use warnings;
my %missing = map {
eval qq{ require $_ };
$@ ? ($_=>1) : ()
} qw( Data::Dumper base strict warnings );
if(%missing)
{
view release on metacpan or search on metacpan
t/00_diag.t view on Meta::CPAN
}
pass 'okay';
my $max = 1;
$max = $_ > $max ? $_ : $max for map { length $_ } @modules;
our $format = "%-${max}s %s";
spacer;
my @keys = sort grep /(MOJO|PERL|\A(LC|HARNESS)_|\A(SHELL|LANG)\Z)/i, keys %ENV;
view release on metacpan or search on metacpan
t/pod-spelling.t view on Meta::CPAN
plan skip_all => 'POD tests are only run in RELEASE_TESTING mode.' unless $ENV{'RELEASE_TESTING'};
eval 'use Test::Spelling 0.19';
plan skip_all => 'Test::Spelling v0.19 required for testing POD' if $@;
add_stopwords( map { split /[\s\:\-]/ } readline(*DATA) );
$ENV{LANG} = 'C';
all_pod_files_spelling_ok();
__DATA__
MERCHANTABILITY