hexsha
stringlengths 40
40
| size
int64 3
1.05M
| ext
stringclasses 163
values | lang
stringclasses 53
values | max_stars_repo_path
stringlengths 3
945
| max_stars_repo_name
stringlengths 4
112
| max_stars_repo_head_hexsha
stringlengths 40
78
| max_stars_repo_licenses
sequencelengths 1
10
| max_stars_count
float64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 3
945
| max_issues_repo_name
stringlengths 4
113
| max_issues_repo_head_hexsha
stringlengths 40
78
| max_issues_repo_licenses
sequencelengths 1
10
| max_issues_count
float64 1
116k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 3
945
| max_forks_repo_name
stringlengths 4
113
| max_forks_repo_head_hexsha
stringlengths 40
78
| max_forks_repo_licenses
sequencelengths 1
10
| max_forks_count
float64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 3
1.05M
| avg_line_length
float64 1
966k
| max_line_length
int64 1
977k
| alphanum_fraction
float64 0
1
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ed8e188efaab0fd0cef54b947f6d11351b964059 | 3,062 | pl | Perl | perl/src/Porting/expand-macro.pl | nokibsarkar/sl4a | d3c17dca978cbeee545e12ea240a9dbf2a6999e9 | [
"Apache-2.0"
] | 2,293 | 2015-01-02T12:46:10.000Z | 2022-03-29T09:45:43.000Z | perl/src/Porting/expand-macro.pl | nokibsarkar/sl4a | d3c17dca978cbeee545e12ea240a9dbf2a6999e9 | [
"Apache-2.0"
] | 315 | 2015-05-31T11:55:46.000Z | 2022-01-12T08:36:37.000Z | perl/src/Porting/expand-macro.pl | nokibsarkar/sl4a | d3c17dca978cbeee545e12ea240a9dbf2a6999e9 | [
"Apache-2.0"
] | 1,033 | 2015-01-04T07:48:40.000Z | 2022-03-24T09:34:37.000Z | #!perl -w
use strict;
use Pod::Usage;
use Getopt::Std;
$Getopt::Std::STANDARD_HELP_VERSION = 1;
my $trysource = "try.c";
my $tryout = "try.i";
getopts('fF:ekvI:', \my %opt) or pod2usage();
my($expr, @headers) = @ARGV ? splice @ARGV : "-";
pod2usage "-f and -F <tool> are exclusive\n" if $opt{f} and $opt{F};
foreach($trysource, $tryout) {
unlink $_ if $opt{e};
die "You already have a $_" if -e $_;
}
if ($expr eq '-') {
warn "reading from stdin...\n";
$expr = do { local $/; <> };
}
my($macro, $args) = $expr =~ /^\s*(\w+)((?:\s*\(.*\))?)\s*;?\s*$/s
or pod2usage "$expr doesn't look like a macro-name or macro-expression to me";
if (!(@ARGV = @headers)) {
open my $fh, '<', 'MANIFEST' or die "Can't open MANIFEST: $!";
while (<$fh>) {
push @ARGV, $1 if m!^([^/]+\.h)\t!;
}
push @ARGV, 'config.h' if -f 'config.h';
}
my $header;
while (<>) {
next unless /^#\s*define\s+$macro\b/;
my ($def_args) = /^#\s*define\s+$macro\(([^)]*)\)/;
if (defined $def_args && !$args) {
my @args = split ',', $def_args;
print "# macro: $macro args: @args in $_\n" if $opt{v};
my $argname = "A0";
$args = '(' . join (', ', map {$argname++} 1..@args) . ')';
}
$header = $ARGV;
last;
}
die "$macro not found\n" unless defined $header;
open my $out, '>', $trysource or die "Can't open $trysource: $!";
my $sentinel = "$macro expands to";
print $out <<"EOF";
#include "EXTERN.h"
#include "perl.h"
EOF
print qq{#include "$header"\n}
unless $header eq 'perl.h' or $header eq 'EXTERN.h';
print $out <<"EOF";
#line 4 "$sentinel"
$macro$args
EOF
close $out or die "Can't close $trysource: $!";
print "doing: make $tryout\n" if $opt{v};
system "make $tryout" and die;
# if user wants 'indent' formatting ..
my $out_fh;
if ($opt{f} || $opt{F}) {
# a: indent is a well behaved filter when given 0 arguments, reading from
# stdin and writing to stdout
# b: all our braces should be balanced, indented back to column 0, in the
# headers, hence everything before our #line directive can be ignored
#
# We can take advantage of this to reduce the work to indent.
my $indent_command = $opt{f} ? 'indent' : $opt{F};
if (defined $opt{I}) {
$indent_command .= " $opt{I}";
}
open $out_fh, '|-', $indent_command or die $?;
} else {
$out_fh = \*STDOUT;
}
open my $fh, '<', $tryout or die "Can't open $tryout: $!";
while (<$fh>) {
print $out_fh $_ if /$sentinel/o .. 1;
}
unless ($opt{k}) {
foreach($trysource, $tryout) {
die "Can't unlink $_" unless unlink $_;
}
}
__END__
=head1 NAME
expand-macro.pl - expand C macros using the C preprocessor
=head1 SYNOPSIS
expand-macro.pl [options] [ < macro-name | macro-expression | - > [headers] ]
options:
-f use 'indent' to format output
-F <tool> use <tool> to format output (instead of -f)
-e erase try.[ic] instead of failing when they're present (errdetect)
-k keep them after generating (for handy inspection)
-v verbose
-I <indent-opts> passed into indent
=cut
| 24.110236 | 82 | 0.588831 |
edb4cc471991ae40b178ffff979b31112e892da3 | 980 | pm | Perl | pdu-perl-api/Raritan/RPC/pdumodel/PowerMeter_1_1_2/EnergyPulseSettings.pm | gregoa/raritan-pdu-json-rpc-sdk | 76df982462742b97b52872aa34630140f5df7e58 | [
"BSD-3-Clause"
] | 1 | 2021-04-29T23:04:17.000Z | 2021-04-29T23:04:17.000Z | pdu-perl-api/Raritan/RPC/pdumodel/PowerMeter_1_1_2/EnergyPulseSettings.pm | gregoa/raritan-pdu-json-rpc-sdk | 76df982462742b97b52872aa34630140f5df7e58 | [
"BSD-3-Clause"
] | null | null | null | pdu-perl-api/Raritan/RPC/pdumodel/PowerMeter_1_1_2/EnergyPulseSettings.pm | gregoa/raritan-pdu-json-rpc-sdk | 76df982462742b97b52872aa34630140f5df7e58 | [
"BSD-3-Clause"
] | 2 | 2020-06-20T16:21:23.000Z | 2021-09-28T19:04:44.000Z | # SPDX-License-Identifier: BSD-3-Clause
#
# Copyright 2020 Raritan Inc. All rights reserved.
#
# This file was generated by IdlC from PowerMeter.idl.
use strict;
package Raritan::RPC::pdumodel::PowerMeter_1_1_2::EnergyPulseSettings;
sub encode {
my ($in) = @_;
my $encoded = {};
$encoded->{'pulseEnabled'} = ($in->{'pulseEnabled'}) ? JSON::true : JSON::false;
$encoded->{'poles'} = [];
for (my $i0 = 0; $i0 <= $#{$in->{'poles'}}; $i0++) {
$encoded->{'poles'}->[$i0] = 1 * $in->{'poles'}->[$i0];
}
$encoded->{'pulsesPerKWh'} = 1 * $in->{'pulsesPerKWh'};
return $encoded;
}
sub decode {
my ($agent, $in) = @_;
my $decoded = {};
$decoded->{'pulseEnabled'} = ($in->{'pulseEnabled'}) ? 1 : 0;
$decoded->{'poles'} = [];
for (my $i0 = 0; $i0 <= $#{$in->{'poles'}}; $i0++) {
$decoded->{'poles'}->[$i0] = $in->{'poles'}->[$i0];
}
$decoded->{'pulsesPerKWh'} = $in->{'pulsesPerKWh'};
return $decoded;
}
1;
| 27.222222 | 84 | 0.532653 |
ed7569e254a7258e66c91234f2f069ff4e91d582 | 1,285 | pm | Perl | core/server/OpenXPKI/SOAP.pm | takerukoushirou/openxpki | 17845b6e853d1a75c91352d79d9c33a90f5e6148 | [
"Apache-2.0"
] | 357 | 2015-02-19T18:23:12.000Z | 2022-03-29T04:05:25.000Z | core/server/OpenXPKI/SOAP.pm | takerukoushirou/openxpki | 17845b6e853d1a75c91352d79d9c33a90f5e6148 | [
"Apache-2.0"
] | 604 | 2015-01-19T11:58:44.000Z | 2022-03-14T13:38:42.000Z | core/server/OpenXPKI/SOAP.pm | takerukoushirou/openxpki | 17845b6e853d1a75c91352d79d9c33a90f5e6148 | [
"Apache-2.0"
] | 108 | 2015-03-10T19:05:20.000Z | 2022-03-29T04:32:28.000Z | package OpenXPKI::SOAP;
use strict;
use warnings;
use English;
use Config::Std;
use Data::Dumper;
use SOAP::Transport::HTTP;
#use SOAP::Transport::HTTP2; # Please adjust contructor call below, if you switch this!
use OpenXPKI::Log4perl;
my $configfile = $ENV{OPENXPKI_SOAP_CONFIG_FILE} || '/etc/openxpki/soap/default.conf';
my $config;
if (! read_config $configfile, $config) {
die "Could not open SOAP interface config file $configfile";
}
my $log_config = $config->{global}->{log_config};
if (! $log_config) {
die "Could not get Log4perl configuration file from config file";
}
my $facility = $config->{global}->{log_facility};
if (! $facility) {
die "Could not get Log4perl logging facility from config file";
}
OpenXPKI::Log4perl->init_or_fallback( $log_config );
my $log = Log::Log4perl->get_logger($facility);
$log->info("SOAP handler initialized from config file $configfile");
my @soap_modules;
foreach my $key (keys %{$config}) {
if ($key =~ /(OpenXPKI::SOAP::[:\w\d]+)/) {
push @soap_modules, $1;
}
}
$log->debug('Modules loaded: ' . join(", ", @soap_modules));
sub handler {
#warn "Entered OpenXPKI::Server::SOAP::handler";
my $oSoapHandler = SOAP::Transport::HTTP::CGI
->dispatch_to( @soap_modules )->handle;
}
1;
| 23.796296 | 87 | 0.679377 |
edb538e684dd1b1e94c99e1736e5c8516eb7bd8b | 1,963 | pl | Perl | 2015/14/aoc.pl | beanz/advent | d5ceeae48483d25b81aaf06ef3faf79521af14b1 | [
"MIT"
] | null | null | null | 2015/14/aoc.pl | beanz/advent | d5ceeae48483d25b81aaf06ef3faf79521af14b1 | [
"MIT"
] | null | null | null | 2015/14/aoc.pl | beanz/advent | d5ceeae48483d25b81aaf06ef3faf79521af14b1 | [
"MIT"
] | null | null | null | #!/usr/bin/perl
use warnings FATAL => 'all';
use strict;
use v5.20;
use lib "../../lib-perl";
use AoC::Helpers qw/:all/;
use Carp::Always qw/carp verbose/;
my $endTime = 2503;
$endTime = 1000 if (@ARGV && $ARGV[0] eq 'test1.txt');
my @i = @{read_lines(shift//"input.txt")};
sub calc_aux {
my ($i, $end) = @_;
my %r;
for my $l (@$i) {
next unless ($l =~
m!(.*) can fly (\d+) km/s for (\d+) seconds, .* for (\d+)!);
$r{$1} = { v => $2, vs => $3, rs => $4, d => 0, move => $3, score => 0 };
}
my $t = 0;
while ($t < $end) {
for my $v (values %r) {
if (exists $v->{move}) {
if ($v->{move} > 0) {
$v->{d} += $v->{v};
$v->{move}--;
if ($v->{move} == 0) {
delete $v->{move};
$v->{rest} = $v->{rs};
}
}
} else {
if ($v->{rest} > 0) {
$v->{rest}--;
if ($v->{rest} == 0) {
delete $v->{rest};
$v->{move} = $v->{vs};
}
}
}
}
my $d = max(map { $_->{d} } values %r);
for my $n (keys %r) {
if ($d == $r{$n}->{d}) {
$r{$n}->{score}++;
}
}
$t++;
}
return \%r;
}
sub calc {
my $r = calc_aux(@_);
return max(map { $_->{d} } values %$r);
}
my @test_input = split/\n/, <<'EOF';
Comet can fly 14 km/s for 10 seconds, but then must rest for 127 seconds.
Dancer can fly 16 km/s for 11 seconds, but then must rest for 162 seconds.
EOF
chomp @test_input;
if (TEST) {
assertEq("Test 1", calc(\@test_input, 1000), 1120);
}
print "Part 1: ", calc(\@i, $endTime), "\n";
sub calc2 {
my $r = calc_aux(@_);
if (DEBUG) {
for my $n (keys %$r) {
print "$n: ", $r->{$n}->{score}, "\n";
}
}
return max(map { $_->{score} } values %$r);
}
if (TEST) {
assertEq("Test 2 (1)", calc2(\@test_input, 1), 1);
assertEq("Test 2 (1000)", calc2(\@test_input, 1000), 689);
}
print "Part 2: ", calc2(\@i, $endTime), "\n";
| 22.563218 | 77 | 0.443709 |
ed963cdc084c8e0e1c8c78f7980a8a58f7ab9b99 | 1,130 | t | Perl | t/20_Serializer_Async/11_load_xs.t | szabosteve/elasticsearch-perl | 1ff926c47baed00afcde09326ae5f4b8269dd225 | [
"Apache-2.0"
] | 70 | 2015-03-19T09:19:39.000Z | 2022-03-01T20:06:00.000Z | t/20_Serializer_Async/11_load_xs.t | szabosteve/elasticsearch-perl | 1ff926c47baed00afcde09326ae5f4b8269dd225 | [
"Apache-2.0"
] | 149 | 2015-03-10T20:51:53.000Z | 2022-03-14T19:15:27.000Z | t/20_Serializer_Async/11_load_xs.t | szabosteve/elasticsearch-perl | 1ff926c47baed00afcde09326ae5f4b8269dd225 | [
"Apache-2.0"
] | 51 | 2015-04-23T18:54:18.000Z | 2022-03-10T19:50:16.000Z | # Licensed to Elasticsearch B.V. under one or more contributor
# license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright
# ownership. Elasticsearch B.V. licenses this file to you under
# the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
use Test::More;
use lib sub {
die "No Cpanel" if $_[1] =~ m{Cpanel/JSON/XS.pm$};
return undef;
};
use Search::Elasticsearch;
my $s = Search::Elasticsearch->new()->transport->serializer->JSON;
SKIP: {
skip 'JSON::XS not installed' => 1
unless eval { require JSON::XS; 1 };
isa_ok $s, "JSON::XS", 'JSON::XS';
}
done_testing;
| 29.736842 | 66 | 0.720354 |
ed9eaece635c3e75d88bf8d081d6ff8f0c5933a9 | 705 | pm | Perl | perl/lib/Test/Deep/Code.pm | ifleeyo180/VspriteMoodleWebsite | 38baa924829c83808d2c87d44740ff365927a646 | [
"Apache-2.0"
] | 2 | 2018-04-27T09:12:43.000Z | 2020-10-10T16:32:16.000Z | perl/lib/Test/Deep/Code.pm | ifleeyo180/VspriteMoodleWebsite | 38baa924829c83808d2c87d44740ff365927a646 | [
"Apache-2.0"
] | 16 | 2019-08-28T23:45:01.000Z | 2019-12-20T02:12:13.000Z | perl/lib/Test/Deep/Code.pm | ifleeyo180/VspriteMoodleWebsite | 38baa924829c83808d2c87d44740ff365927a646 | [
"Apache-2.0"
] | 1 | 2020-10-10T16:32:25.000Z | 2020-10-10T16:32:25.000Z | use strict;
use warnings;
package Test::Deep::Code;
use Test::Deep::Cmp;
sub init
{
my $self = shift;
my $code = shift || die "No coderef supplied";
$self->{code} = $code;
}
sub descend
{
my $self = shift;
my $got = shift;
my ($ok, $diag) = &{$self->{code}}($got);
$self->data->{diag} = $diag;
return $ok;
}
sub diagnostics
{
my $self = shift;
my ($where, $last) = @_;
my $error = $last->{diag};
my $data = Test::Deep::render_val($last->{got});
my $diag = <<EOM;
Ran coderef at $where on
$data
EOM
if (defined($error))
{
$diag .= <<EOM;
and it said
$error
EOM
}
else
{
$diag .= <<EOM;
it failed but it didn't say why.
EOM
}
return $diag;
}
1;
| 11.949153 | 50 | 0.557447 |
eda984521b341b7c51ac92cee3e02148db2fef72 | 1,589 | pl | Perl | Task/LZW-compression/Perl/lzw-compression.pl | mullikine/RosettaCodeData | 4f0027c6ce83daa36118ee8b67915a13cd23ab67 | [
"Info-ZIP"
] | 1 | 2018-11-09T22:08:38.000Z | 2018-11-09T22:08:38.000Z | Task/LZW-compression/Perl/lzw-compression.pl | mullikine/RosettaCodeData | 4f0027c6ce83daa36118ee8b67915a13cd23ab67 | [
"Info-ZIP"
] | null | null | null | Task/LZW-compression/Perl/lzw-compression.pl | mullikine/RosettaCodeData | 4f0027c6ce83daa36118ee8b67915a13cd23ab67 | [
"Info-ZIP"
] | 1 | 2018-11-09T22:08:40.000Z | 2018-11-09T22:08:40.000Z | # Compress a string to a list of output symbols.
sub compress {
my $uncompressed = shift;
# Build the dictionary.
my $dict_size = 256;
my %dictionary = map {chr $_ => chr $_} 0..$dict_size-1;
my $w = "";
my @result;
foreach my $c (split '', $uncompressed) {
my $wc = $w . $c;
if (exists $dictionary{$wc}) {
$w = $wc;
} else {
push @result, $dictionary{$w};
# Add wc to the dictionary.
$dictionary{$wc} = $dict_size;
$dict_size++;
$w = $c;
}
}
# Output the code for w.
if ($w) {
push @result, $dictionary{$w};
}
return @result;
}
# Decompress a list of output ks to a string.
sub decompress {
my @compressed = @_;
# Build the dictionary.
my $dict_size = 256;
my %dictionary = map {chr $_ => chr $_} 0..$dict_size-1;
my $w = shift @compressed;
my $result = $w;
foreach my $k (@compressed) {
my $entry;
if (exists $dictionary{$k}) {
$entry = $dictionary{$k};
} elsif ($k == $dict_size) {
$entry = $w . substr($w,0,1);
} else {
die "Bad compressed k: $k";
}
$result .= $entry;
# Add w+entry[0] to the dictionary.
$dictionary{$dict_size} = $w . substr($entry,0,1);
$dict_size++;
$w = $entry;
}
return $result;
}
# How to use:
my @compressed = compress('TOBEORNOTTOBEORTOBEORNOT');
print "@compressed\n";
my $decompressed = decompress(@compressed);
print "$decompressed\n";
| 24.075758 | 60 | 0.511643 |
edc79950bb0dbbc9b626e2aed1db4636a66fbbd6 | 5,654 | pl | Perl | src/test/regress/gpsourcify.pl | lintzc/GPDB | b48c8b97da18f495c10065d0853db87960aebae2 | [
"PostgreSQL",
"Apache-2.0"
] | 1 | 2017-09-15T06:09:56.000Z | 2017-09-15T06:09:56.000Z | src/test/regress/gpsourcify.pl | lintzc/GPDB | b48c8b97da18f495c10065d0853db87960aebae2 | [
"PostgreSQL",
"Apache-2.0"
] | null | null | null | src/test/regress/gpsourcify.pl | lintzc/GPDB | b48c8b97da18f495c10065d0853db87960aebae2 | [
"PostgreSQL",
"Apache-2.0"
] | 1 | 2018-12-04T09:13:57.000Z | 2018-12-04T09:13:57.000Z | #!/usr/bin/env perl
#
# Copyright (c) 2007-2012 GreenPlum. All rights reserved.
# Author: Jeffrey I Cohen
#
#
use Pod::Usage;
use Getopt::Long;
use strict;
use warnings;
use POSIX;
use File::Spec;
use Env;
use Data::Dumper;
=head1 NAME
B<gpsourcify.pl> - GreenPlum reverse string substitution
=head1 SYNOPSIS
B<gpsourcify.pl> filename
Options:
-help brief help message
-man full documentation
-token_file (optional) file with list of tokens and
replacement values (gptokencheck by default)
-dlsuffix if flag is set, replace DLSUFFIX (false by default)
=head1 OPTIONS
=over 8
=item B<-help>
Print a brief help message and exits.
=item B<-man>
Prints the manual page and exits.
=item B<-token_file> (optional: gptokencheck by default)
File which contains a list of token/value pairs. If a filename is
not specified, gpsourcify looks for gptokencheck.out under
$PWD/results.
=item B<-dlsuffix> (false by default)
Because the DLSUFFIX is so small (".so" on unix), there is the
potential for erroneous replacement. Only replace if -dlsuffix is
specified. Do not replace by default, or if -nodlsuffix is specified.
=back
=head1 DESCRIPTION
gpsourcify reads a pg_regress ".out" file as input and rewrites it to
stdout, replacing certain local or environmental values with portable
tokens. The output is a candidate for a pg_regress ".source" file.
gpsourcify is the complement to the gpstringsubs and pg_regress
"convert_sourcefiles_in" functions.
=head1 CAVEATS/LIMITATIONS
In general, gpsourcify always replaces the longest string values
first, so you don't have to worry about some type of string
replacement collision. However, if abs_srcdir and abs_builddir are
identical values (like on unix), gpsourcify uses the heuristic that
source directory references are less common, and usually followed by
"/data". This may not do what you want.
=head1 AUTHORS
Jeffrey I Cohen
Copyright (c) 2007-2012 GreenPlum. All rights reserved.
Address bug reports and comments to: [email protected]
=cut
my $glob_id = "";
my $glob_token_file;
my $glob_dlsuffix;
BEGIN {
my $man = 0;
my $help = 0;
my $tokenf = '';
my $dlsuf = ''; # negatable, ie -dlsuffix or -nodlsuffix
GetOptions(
'help|?' => \$help, man => \$man,
'dlsuffix!' => \$dlsuf,
'token_file:s' => \$tokenf
)
or pod2usage(2);
pod2usage(-msg => $glob_id, -exitstatus => 1) if $help;
pod2usage(-msg => $glob_id, -exitstatus => 0, -verbose => 2) if $man;
$glob_dlsuffix = $dlsuf;
$glob_token_file = length($tokenf) ? $tokenf : "results/gptokencheck.out";
unless (-f $glob_token_file)
{
if (length($tokenf))
{
warn("ERROR: Cannot find specified token file: $glob_token_file");
}
else
{
warn("ERROR: Need to run test gptokencheck to generate token file:\n\n\tmake installcheck-good TT=gptokencheck\n\n");
}
$glob_id = "ERROR - invalid file: $glob_token_file\n";
pod2usage(-msg => $glob_id, -exitstatus => 1, -verbose => 0);
}
# print "loading...\n";
}
sub LoadTokens
{
my $fil = shift;
return undef
unless (defined($fil) && (-f $fil));
my $ini = `grep 'is_transformed_to' $fil`;
$ini =~ s/^\-\-\s+//gm;
# print $ini;
my @foo = split(/\n/, $ini);
my $bigh = {};
for my $kv (@foo)
{
my @baz = split(/\s*\#is\_transformed\_to\#\s*/, $kv, 2);
if (2 == scalar(@baz))
{
$bigh->{$baz[0]} = quotemeta($baz[1]);
}
}
# print Data::Dumper->Dump([$bigh]);
return $bigh;
}
if (1)
{
my $bigh = LoadTokens($glob_token_file);
exit(0) unless (defined($bigh));
# make an array of the token names (keys), sorted descending by
# the length of of the replacement value.
my @sortlen;
@sortlen =
sort {length($bigh->{$b}) <=> length($bigh->{$a})} keys %{$bigh};
my $src_eq_build = 0;
if (exists($bigh->{abs_srcdir})
&& exists($bigh->{abs_builddir}))
{
# see if build directory and source directory are the same...
$src_eq_build = ($bigh->{abs_srcdir} eq $bigh->{abs_builddir});
}
# print Data::Dumper->Dump(\@sortlen);
while (<>)
{
my $ini = $_;
for my $kk (@sortlen)
{
my $vv = $bigh->{$kk};
my $k2 = '@' . $kk . '@';
if ($kk =~ m/DLSUFFIX/ && !$glob_dlsuffix)
{
# ignore if -nodlsuffix
next;
}
if (($kk =~ m/abs_srcdir/) && $src_eq_build)
{
my $v2 = $vv . "/data";
my $k3 = $k2 . "/data";
# replace the srcdir only if followed by "/data"
$ini =~ s/$v2/$k3/g;
# or "include/catalog"
my $v3 = $vv . "/../../include/catalog";
my $k4 = $k2 . "/../../include/catalog";
$ini =~ s/$v3/$k4/g;
}
elsif (($kk =~ m/abs_builddir/) && $src_eq_build)
{
my $regex1 =
"/data" . "|" .
"/../../include/catalog";
# replace buildir if not followed by "/data"
# or "include/catalog"
# (negative look-ahead)
$ini =~
s/$vv(?!($regex1))/$k2/g;
}
else
{
$ini =~ s/$vv/$k2/g;
}
}
print $ini;
}
exit(0);
}
| 23.85654 | 120 | 0.558543 |
ed5cd2fc40c2debd7666bc23d564d1cb56ecc2e5 | 1,486 | pl | Perl | i3/scripts/cpu_usage.pl | bagool185/dotfiles | cd3edb52d355ddae201c16ad9b9d158175cbc43f | [
"MIT"
] | null | null | null | i3/scripts/cpu_usage.pl | bagool185/dotfiles | cd3edb52d355ddae201c16ad9b9d158175cbc43f | [
"MIT"
] | null | null | null | i3/scripts/cpu_usage.pl | bagool185/dotfiles | cd3edb52d355ddae201c16ad9b9d158175cbc43f | [
"MIT"
] | null | null | null | #!/usr/bin/perl
#
# Copyright 2014 Pierre Mavro <[email protected]>
# Copyright 2014 Vivien Didelot <[email protected]>
# Copyright 2014 Andreas Guldstrand <[email protected]>
#
# Licensed under the terms of the GNU GPL v3, or any later version.
use strict;
use warnings;
use utf8;
use Getopt::Long;
# default values
my $t_warn = 50;
my $t_crit = 80;
my $cpu_usage = -1;
my $decimals = 2;
sub help {
print "Usage: cpu_usage [-w <warning>] [-c <critical>] [-d <decimals>]\n";
print "-w <percent>: warning threshold to become yellow\n";
print "-c <percent>: critical threshold to become red\n";
print "-d <decimals>: Use <decimals> decimals for percentage (default is $decimals) \n";
exit 0;
}
GetOptions("help|h" => \&help,
"w=i" => \$t_warn,
"c=i" => \$t_crit,
"d=i" => \$decimals,
);
# Get CPU usage
$ENV{LC_ALL}="en_US"; # if mpstat is not run under en_US locale, things may break, so make sure it is
open (MPSTAT, 'mpstat 1 1 |') or die;
while (<MPSTAT>) {
if (/^.*\s+(\d+\.\d+)\s+$/) {
$cpu_usage = 100 - $1; # 100% - %idle
last;
}
}
close(MPSTAT);
$cpu_usage eq -1 and die 'Can\'t find CPU information';
# Print short_text, full_text
printf "%.${decimals}f%%\n", $cpu_usage;
printf "%.${decimals}f%%\n", $cpu_usage;
# Print color, if needed
if ($cpu_usage >= $t_crit) {
print "#FF0000\n";
exit 33;
} elsif ($cpu_usage >= $t_warn) {
print "#FFFC00\n";
}
exit 0;
| 24.766667 | 101 | 0.611709 |
edb81f1441264997b799e06bb1da899644dfe1f2 | 2,708 | pm | Perl | lib/Perl/Critic/Policy/InputOutput/ProhibitReadlineInForLoop.pm | clayne/Perl-Critic | 8e62c3989feb27c9b9d9b593a51026d202174149 | [
"Artistic-1.0"
] | 128 | 2015-01-28T16:35:31.000Z | 2022-02-24T17:40:16.000Z | lib/Perl/Critic/Policy/InputOutput/ProhibitReadlineInForLoop.pm | clayne/Perl-Critic | 8e62c3989feb27c9b9d9b593a51026d202174149 | [
"Artistic-1.0"
] | 411 | 2015-01-06T16:07:30.000Z | 2022-03-16T21:46:28.000Z | lib/Perl/Critic/Policy/InputOutput/ProhibitReadlineInForLoop.pm | clayne/Perl-Critic | 8e62c3989feb27c9b9d9b593a51026d202174149 | [
"Artistic-1.0"
] | 94 | 2015-01-16T00:33:31.000Z | 2022-03-18T05:41:00.000Z | package Perl::Critic::Policy::InputOutput::ProhibitReadlineInForLoop;
use 5.006001;
use strict;
use warnings;
use Readonly;
use List::Util qw< first >;
use Perl::Critic::Utils qw{ :severities };
use base 'Perl::Critic::Policy';
our $VERSION = '1.140';
#-----------------------------------------------------------------------------
Readonly::Scalar my $DESC => q{Readline inside "for" loop};
Readonly::Scalar my $EXPL => [ 211 ];
#-----------------------------------------------------------------------------
sub supported_parameters { return () }
sub default_severity { return $SEVERITY_HIGH }
sub default_themes { return qw< core bugs pbp > }
sub applies_to { return qw< PPI::Statement::Compound > }
#-----------------------------------------------------------------------------
sub violates {
my ( $self, $elem, undef ) = @_;
return if $elem->type() ne 'foreach';
my $list = first { $_->isa('PPI::Structure::List') } $elem->schildren()
or return;
if (
my $readline = $list->find_first('PPI::Token::QuoteLike::Readline')
) {
return $self->violation( $DESC, $EXPL, $readline );
}
return; #ok!
}
1;
__END__
#-----------------------------------------------------------------------------
=pod
=head1 NAME
Perl::Critic::Policy::InputOutput::ProhibitReadlineInForLoop - Write C<< while( $line = <> ){...} >> instead of C<< for(<>){...} >>.
=head1 AFFILIATION
This Policy is part of the core L<Perl::Critic|Perl::Critic>
distribution.
=head1 DESCRIPTION
Using the readline operator in a C<for> or C<foreach> loop is very
slow. The iteration list of the loop creates a list context, which
causes the readline operator to read the entire input stream before
iteration even starts. Instead, just use a C<while> loop, which only
reads one line at a time.
for my $line ( <$file_handle> ){ do_something($line) } #not ok
while ( my $line = <$file_handle> ){ do_something($line) } #ok
=head1 CONFIGURATION
This Policy is not configurable except for the standard options.
=head1 AUTHOR
Jeffrey Ryan Thalhammer <[email protected]>
=head1 COPYRIGHT
Copyright (c) 2005-2011 Imaginative Software Systems. All rights reserved.
This program is free software; you can redistribute it and/or modify
it under the same terms as Perl itself. The full text of this license
can be found in the LICENSE file included with this module.
=cut
# Local Variables:
# mode: cperl
# cperl-indent-level: 4
# fill-column: 78
# indent-tabs-mode: nil
# c-indentation-style: bsd
# End:
# ex: set ts=8 sts=4 sw=4 tw=78 ft=perl expandtab shiftround :
| 26.291262 | 132 | 0.590473 |
ed6d0b8fc0b237d3a424b27dcd30b425b6c2bbdf | 4,372 | pm | Perl | lib/CPrAN/Plugin.pm | cpran/CPrAN | 62ea73a52f40bfe00413d7c40884b267afbe6f80 | [
"Artistic-1.0"
] | null | null | null | lib/CPrAN/Plugin.pm | cpran/CPrAN | 62ea73a52f40bfe00413d7c40884b267afbe6f80 | [
"Artistic-1.0"
] | null | null | null | lib/CPrAN/Plugin.pm | cpran/CPrAN | 62ea73a52f40bfe00413d7c40884b267afbe6f80 | [
"Artistic-1.0"
] | null | null | null | package CPrAN::Plugin;
# ABSTRACT: A representation of a Praat plugin
our $VERSION = '0.0413'; # VERSION
use Moose;
extends 'Praat::Plugin';
use Types::Praat qw( Version );
use Types::Path::Tiny qw( Path );
use Types::Standard qw( Bool Undef );
has cpran => (
is => 'rw',
isa => Path|Undef,
coerce => 1,
);
has url => (
is => 'rw',
);
has [qw( version latest requested )] => (
is => 'rw',
isa => Version|Undef,
coerce => 1,
);
has '+latest' => (
lazy => 1,
default => sub { $_[0]->_remote->{version} },
);
has '+version' => (
lazy => 1,
default => sub { $_[0]->_local->{version} },
);
has '+requested' => (
lazy => 1,
default => sub { $_[0]->latest },
);
has [qw( _remote _local )] => (
is => 'rw',
isa => 'HashRef',
lazy => 1,
default => sub { {} },
);
has [qw( is_cpran )] => (
is => 'rw',
isa => 'Bool',
lazy => 1,
default => 0,
);
around BUILDARGS => sub {
my $orig = shift;
my $self = shift;
my $args = $self->$orig(@_);
if (defined $args->{meta}) {
if (ref $args->{meta} eq 'HASH') {
$args->{name} = $args->{meta}->{name};
$args->{url} = $args->{meta}->{http_url_to_repo};
}
else {
# Treat as an unserialised plugin descriptor
my $meta = $self->_parse_meta($args->{meta});
if (defined $meta) {
$args->{name} = $meta->{plugin};
$args->{_remote} = $meta;
}
}
delete $args->{meta};
}
if ($args->{name} =~ /:/) {
my ($n, $v) = split /:/, $args->{name};
$args->{name} = $n;
$args->{requested} = $v unless $v eq 'latest';
}
$args->{name} =~ s/^plugin_([\w\d]+)/$1/;
return $args;
};
sub refresh {
my ($self) = @_;
if (defined $self->root) {
my $local = $self->root->child('cpran.yaml');
$self->_local( $self->parse_meta( $local->slurp )) if $local->exists;
}
$self->version($self->_local->{version}) if defined $self->_local;
if (defined $self->cpran) {
my $remote = $self->cpran->child( $self->name );
$self->_remote( $self->parse_meta( $remote->slurp )) if $remote->exists;
}
$self->latest($self->_remote->{version}) if defined $self->_remote;
return $self;
}
sub is_latest {
my ($self) = @_;
return undef unless scalar keys %{$self->_remote};
return 0 unless scalar keys %{$self->_local};
$self->refresh;
return ($self->version >= $self->latest) ? 1 : 0;
}
sub remove {
my $self = shift;
my $opt = (@_) ? (@_ > 1) ? { @_ } : shift : {};
return undef unless defined $self->root;
return 0 unless $self->root->exists;
$self->root->remove_tree({
verbose => $opt->{verbose},
safe => 0,
error => \my $e
});
if (@{$e}) {
foreach (@{$e}) {
my ($file, $message) = %{$_};
if ($file eq '') {
Carp::carp "General error: $message\n";
}
else {
Carp::carp "Problem unlinking $file: $message\n";
}
}
Carp::croak 'Could not completely remove ', $self->root;
}
else {
return 1;
}
}
sub print {
use Encode qw( decode );
my ($self, $name) = @_;
$name = '_' . $name;
die "Not a valid field"
unless $name =~ /^_(local|remote)$/;
die "No descriptor found"
unless defined $self->$name;
print decode('utf8',
$self->$name->{meta}
);
}
sub parse_meta {
my ($self, $meta) = @_;
my $parsed = $self->_parse_meta($meta);
$self->is_cpran(1) if $parsed;
return $parsed;
}
sub _parse_meta {
my ($class, $meta) = @_;
require YAML::XS;
require Encode;
use Syntax::Keyword::Try;
my $parsed;
try {
$parsed = YAML::XS::Load( Encode::encode_utf8( $meta ));
}
catch {
Carp::croak 'Could not deserialise meta: ', $meta;
}
_force_lc_hash($parsed);
$parsed->{meta} = $meta;
$parsed->{name} = $parsed->{plugin};
if (ref $parsed->{version} ne 'Praat::Version') {
try {
require Praat::Version;
$parsed->{version} = Praat::Version->new($parsed->{version})
}
catch {
Carp::croak 'Not a valid version number: ', $parsed->{version};
}
}
return $parsed;
}
sub _force_lc_hash {
my $hashref = shift;
if (ref $hashref eq 'HASH') {
foreach my $key (keys %{$hashref} ) {
$hashref->{lc($key)} = $hashref->{$key};
_force_lc_hash($hashref->{lc($key)}) if ref $hashref->{$key} eq 'HASH';
delete($hashref->{$key}) unless $key eq lc($key);
}
}
}
1;
| 19.605381 | 77 | 0.538198 |
ed4086721614b0e732eb3e226e4115e5fc60aeee | 2,300 | pl | Perl | test/fwdbck/checkNSIFB.pl | bkragl/corral | 958fbb6809ecba2ad43ffa438e780a2660bf06c6 | [
"MIT"
] | 43 | 2016-04-15T20:10:30.000Z | 2022-02-16T04:51:29.000Z | test/fwdbck/checkNSIFB.pl | bkragl/corral | 958fbb6809ecba2ad43ffa438e780a2660bf06c6 | [
"MIT"
] | 114 | 2016-04-16T22:16:03.000Z | 2021-07-09T01:39:35.000Z | test/fwdbck/checkNSIFB.pl | bkragl/corral | 958fbb6809ecba2ad43ffa438e780a2660bf06c6 | [
"MIT"
] | 40 | 2016-04-16T02:55:31.000Z | 2022-02-25T23:55:49.000Z | open (FINAL_OUTPUT, "Files") || die "cannot read Files";
@files = <FINAL_OUTPUT>;
close (FINAL_OUTPUT);
# One can give the explicit directory name to execute
# all tests in that directory
$numArgs = $#ARGV + 1;
$dirsGiven = 0;
$flags = "";
$timeout = ""; #wlimit.exe /w 60";
@dirs = ("");
for($cnt = 0; $cnt < $numArgs; $cnt++) {
#print substr($ARGV[$cnt],0,1);
if(substr($ARGV[$cnt],0,1) =~ '/') {
$flags = "$flags $ARGV[$cnt]";
} else {
$dirsGiven = 1;
unshift(@dirs, "$ARGV[$cnt]\\\\");
}
}
foreach $line (@files) {
# Spilt into file name and expected output
@inp = split( / +/, $line);
$file = $inp[0];
# skip empty lines
if($file eq "") {
next;
}
$out = $inp[1];
# Remove end of line
@tmp = split(/\n/, $out);
$out = $tmp[0];
# if target directories have been given, ignore other directories
if($dirsGiven) {
$found = 0;
for($cnt = 0; $cnt < $#dirs; $cnt++) {
$dir = $dirs[$cnt];
#print $dir; print "\n";
#print $file; print "\n";
if($file =~ m/^$dir/) {
$found = 1;
}
}
if($found == 0) {
next;
}
}
# get directory name from the file name
@tmp = split(/\\/, $file);
$dir = $tmp[0];
#print "Directory given: $dir";
# check if files exists
open(TMP_HANDLE, $file) || die "File $file does not exist\n";
close (TMP_HANDLE);
$cmd = "$timeout ..\\..\\bin\\Debug\\corral.exe /newStratifiedInlining $file /fwdBck /fwdBckInRef /flags:$dir\\config.txt $flags > out";
#print $cmd; print "\n";
system($cmd);
# Check result
open(TMP_HANDLE, "out") || die "Command did not produce an output\n";
@res = <TMP_HANDLE>;
close(TMP_HANDLE);
$ok = 1;
if($out eq "c") {
@correct = grep (/^Program has no bugs/, @res);
if($correct[0] =~ m/^Program has no bugs/) {
$ok = 1;
} else {
$ok = 0;
}
} else {
@correct = grep (/^Program has a potential bug: True bug/, @res);
if($correct[0] =~ m/^Program has a potential bug: True bug/) {
$ok = 1;
} else {
$ok = 0;
}
}
if($ok == 0) {
#print $correct[0];
print "Test $file failed\n";
} else {
#print $correct[0];
print "Test $file passed\n";
}
}
| 22.54902 | 140 | 0.517826 |
ed5bfd5eb554641e83e8d748ff0056f006466bff | 2,259 | pl | Perl | util/parse_qacct.pl | itmat/rum | 6ab98b6ba65aa34772d32fbedb25e5c1151e2715 | [
"MIT"
] | 7 | 2015-02-03T15:52:20.000Z | 2021-10-31T14:16:11.000Z | util/parse_qacct.pl | ZhengXia/rum | 6ab98b6ba65aa34772d32fbedb25e5c1151e2715 | [
"MIT"
] | 9 | 2015-03-08T18:42:25.000Z | 2022-02-09T06:18:42.000Z | util/parse_qacct.pl | ZhengXia/rum | 6ab98b6ba65aa34772d32fbedb25e5c1151e2715 | [
"MIT"
] | 2 | 2015-01-11T12:06:16.000Z | 2015-04-16T17:38:39.000Z | #!/usr/bin/env perl
use strict;
use warnings;
use List::Util qw(reduce max);
my @jobs;
our @FIELDS = qw(
qname
hostname
jobname
jobnumber
taskid
qsub_time
start_time
end_time
tot_time
ru_wallclock
ru_utime
ru_stime
ru_maxrss
ru_minflt
ru_majflt
ru_nvcsw
ru_nivcsw
cpu
mem
io
maxvmem);
while (defined(local $_ = <ARGV>)) {
if (/^=+$/) {
push @jobs, {};
}
else {
chomp;
my ($k, $v) = split /\s+/, $_, 2;
$v =~ s/^\s*//;
$v =~ s/\s*$//;
$jobs[$#jobs]->{$k} = $v;
}
}
my @formats;
local $_;
sub format_time {
my ($time) = @_;
my $hours = int($time / (60 * 60));
$time -= ($hours * 60 * 60);
my $minutes = int($time / 60);
$time -= $minutes * 60;
sprintf "%02d:%02d:%02d", $hours, $minutes, $time;
}
for my $i (0 .. $#jobs) {
for my $field (qw(qsub_time start_time end_time)) {
$jobs[$i]{$field} = substr $jobs[$i]{$field}, 11, 8;
}
$jobs[$i]->{tot_time} = format_time($jobs[$i]->{ru_wallclock});
}
for (@FIELDS) {
my $width = length;
for my $job (@jobs) {
my $len = length($job->{$_});
$width = $len if $len > $width;
}
push @formats, "%${width}s";
}
my $format = "@formats\n";
printf $format, @FIELDS;
my @parent = grep { $_->{jobname} =~ /rum_runner/ } @jobs;
my @preproc = grep { $_->{jobname} =~ /_preproc/ } @jobs;
my @proc = grep { $_->{jobname} =~ /_proc/ } @jobs;
my @postproc = grep { $_->{jobname} =~ /_postproc/ } @jobs;
@proc = sort { $a->{taskid} <=> $b->{taskid} } @proc;
for my $job (@parent, @preproc, @proc, @postproc) {
my @vals = @$job{@FIELDS};
printf $format, @vals;
}
my @chunk_times = map $_->{ru_wallclock}, @proc;
my $chunk_time = reduce { $a + $b } @chunk_times;
my @total_times = map $_->{ru_wallclock}, @preproc, @proc, @postproc;
my $total_time = reduce { $a + $b } @total_times;
printf "\nSummary:\n";
printf "--------\n";
printf "Total job time: %s\n", format_time($total_time);
printf " Preprocessing: %s\n", format_time($preproc[0]->{ru_wallclock});
printf " Avg. chunk: %s\n", format_time($chunk_time / @proc);
printf " Max. chunk: %s\n", format_time(max @chunk_times);
printf "Postprocessing: %s\n", format_time($postproc[0]->{ru_wallclock});
| 19.99115 | 73 | 0.56618 |
ed8ab8c2fddf7c317f49cab9ff570317e2254e54 | 2,850 | pl | Perl | extlib/bin/bp_aacomp.pl | joelchaconcastillo/srnalightnxtg | a14d50d08a90ce7b3b2d0ea200046ad7a719cdc0 | [
"Apache-2.0"
] | null | null | null | extlib/bin/bp_aacomp.pl | joelchaconcastillo/srnalightnxtg | a14d50d08a90ce7b3b2d0ea200046ad7a719cdc0 | [
"Apache-2.0"
] | null | null | null | extlib/bin/bp_aacomp.pl | joelchaconcastillo/srnalightnxtg | a14d50d08a90ce7b3b2d0ea200046ad7a719cdc0 | [
"Apache-2.0"
] | null | null | null | #!/usr/bin/perl
eval 'exec /usr/bin/perl -S $0 ${1+"$@"}'
if 0; # not running under some shell
use strict;
use warnings;
use Carp;
use Bio::SeqIO;
use Getopt::Long;
use Bio::SeqUtils;
use Bio::Tools::IUPAC;
my $table = new Bio::SeqUtils;
my @BASES = $table->valid_aa(0);
my %all = $table->valid_aa(2);
my ($file,$format,$help) = ( undef, 'fasta');
GetOptions(
'i|in:s' => \$file,
'f|format:s' => \$format,
'h|help|?' => \$help,
);
my $USAGE = "usage: aacomp [-f format] filename\n\tdefault format is fasta\n";
$file = shift unless $file;
die $USAGE if $help;
my $seqin;
if( defined $file ) {
print "Could not open file [$file]\n$USAGE" and exit unless -e $file;
$seqin = new Bio::SeqIO(-format => $format,
-file => $file);
} else {
$seqin = new Bio::SeqIO(-format => $format,
-fh => \*STDIN);
}
my %composition;
my $total;
foreach my $base ( @BASES ) {
$composition{$base} = 0;
}
while ( my $seq = $seqin->next_seq ) {
if( $seq->alphabet ne 'protein' ) {
confess("Must only provide amino acid sequences to aacomp...skipping this seq");
next;
}
foreach my $base ( split(//,$seq->seq()) ) {
$composition{uc $base}++;
$total++;
}
}
printf("%d aa\n",$total);
printf("%5s %4s\n", 'aa', '#' );
my $ct = 0;
foreach my $base ( @BASES ) {
printf(" %s %s %3d\n", $base, $all{$base}, $composition{$base} );
$ct += $composition{$base};
}
printf( "%6s %s\n", '','-'x5);
printf( "%6s %3d\n", '',$ct);
__END__
=head1 NAME
bp_aacomp - amino acid composition of protein sequences
=head1 SYNOPSIS
bp_aacomp [-f/--format FORMAT] [-h/--help] filename
or
bp_aacomp [-f/--format FORMAT] < filename
or
bp_aacomp [-f/--format FORMAT] -i filename
=head1 DESCRIPTION
This scripts prints out the count of amino acids over all protein
sequences from the input file.
=head1 OPTIONS
The default sequence format is fasta.
The sequence input can be provided using any of the three methods:
=over 3
=item unnamed argument
bp_aacomp filename
=item named argument
bp_aacomp -i filename
=item standard input
bp_aacomp < filename
=back
=head1 FEEDBACK
=head2 Mailing Lists
User feedback is an integral part of the evolution of this and other
Bioperl modules. Send your comments and suggestions preferably to
the Bioperl mailing list. Your participation is much appreciated.
[email protected] - General discussion
http://bioperl.org/wiki/Mailing_lists - About the mailing lists
=head2 Reporting Bugs
Report bugs to the Bioperl bug tracking system to help us keep track
of the bugs and their resolution. Bug reports can be submitted via the
web:
https://github.com/bioperl/bioperl-live/issues
=head1 AUTHOR - Jason Stajich
Email [email protected]
=head1 HISTORY
Based on aacomp.c from an old version of EMBOSS
=cut
| 20.955882 | 81 | 0.657895 |
edb6b6528e36f31713bdc7b7b4d0df9c07846be4 | 5,874 | pm | Perl | lib/EzmaxApi/Object/EzsignbulksenddocumentmappingCreateObjectV1Response.pm | ezmaxinc/eZmax-SDK-perl | 3de20235136371b946247d2aed9e5e5704a4051c | [
"MIT"
] | null | null | null | lib/EzmaxApi/Object/EzsignbulksenddocumentmappingCreateObjectV1Response.pm | ezmaxinc/eZmax-SDK-perl | 3de20235136371b946247d2aed9e5e5704a4051c | [
"MIT"
] | null | null | null | lib/EzmaxApi/Object/EzsignbulksenddocumentmappingCreateObjectV1Response.pm | ezmaxinc/eZmax-SDK-perl | 3de20235136371b946247d2aed9e5e5704a4051c | [
"MIT"
] | null | null | null | =begin comment
eZmax API Definition (Full)
This API expose all the functionnalities for the eZmax and eZsign applications.
The version of the OpenAPI document: 1.1.7
Contact: [email protected]
Generated by: https://openapi-generator.tech
=end comment
=cut
#
# NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
# Do not edit the class manually.
# Ref: https://openapi-generator.tech
#
package EzmaxApi::Object::EzsignbulksenddocumentmappingCreateObjectV1Response;
require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Date::Parse;
use DateTime;
use EzmaxApi::Object::CommonResponse;
use EzmaxApi::Object::CommonResponseObjDebug;
use EzmaxApi::Object::CommonResponseObjDebugPayload;
use EzmaxApi::Object::EzsignbulksenddocumentmappingCreateObjectV1ResponseAllOf;
use EzmaxApi::Object::EzsignbulksenddocumentmappingCreateObjectV1ResponseMPayload;
use base ("Class::Accessor", "Class::Data::Inheritable");
#
#Response for POST /1/object/ezsignbulksenddocumentmapping
#
# NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). Do not edit the class manually.
# REF: https://openapi-generator.tech
#
=begin comment
eZmax API Definition (Full)
This API expose all the functionnalities for the eZmax and eZsign applications.
The version of the OpenAPI document: 1.1.7
Contact: [email protected]
Generated by: https://openapi-generator.tech
=end comment
=cut
#
# NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
# Do not edit the class manually.
# Ref: https://openapi-generator.tech
#
__PACKAGE__->mk_classdata('attribute_map' => {});
__PACKAGE__->mk_classdata('openapi_types' => {});
__PACKAGE__->mk_classdata('method_documentation' => {});
__PACKAGE__->mk_classdata('class_documentation' => {});
# new plain object
sub new {
my ($class, %args) = @_;
my $self = bless {}, $class;
$self->init(%args);
return $self;
}
# initialize the object
sub init
{
my ($self, %args) = @_;
foreach my $attribute (keys %{$self->attribute_map}) {
my $args_key = $self->attribute_map->{$attribute};
$self->$attribute( $args{ $args_key } );
}
}
# return perl hash
sub to_hash {
my $self = shift;
my $_hash = decode_json(JSON->new->convert_blessed->encode($self));
return $_hash;
}
# used by JSON for serialization
sub TO_JSON {
my $self = shift;
my $_data = {};
foreach my $_key (keys %{$self->attribute_map}) {
if (defined $self->{$_key}) {
$_data->{$self->attribute_map->{$_key}} = $self->{$_key};
}
}
return $_data;
}
# from Perl hashref
sub from_hash {
my ($self, $hash) = @_;
# loop through attributes and use openapi_types to deserialize the data
while ( my ($_key, $_type) = each %{$self->openapi_types} ) {
my $_json_attribute = $self->attribute_map->{$_key};
if ($_type =~ /^array\[(.+)\]$/i) { # array
my $_subclass = $1;
my @_array = ();
foreach my $_element (@{$hash->{$_json_attribute}}) {
push @_array, $self->_deserialize($_subclass, $_element);
}
$self->{$_key} = \@_array;
} elsif ($_type =~ /^hash\[string,(.+)\]$/i) { # hash
my $_subclass = $1;
my %_hash = ();
while (my($_key, $_element) = each %{$hash->{$_json_attribute}}) {
$_hash{$_key} = $self->_deserialize($_subclass, $_element);
}
$self->{$_key} = \%_hash;
} elsif (exists $hash->{$_json_attribute}) { #hash(model), primitive, datetime
$self->{$_key} = $self->_deserialize($_type, $hash->{$_json_attribute});
} else {
$log->debugf("Warning: %s (%s) does not exist in input hash\n", $_key, $_json_attribute);
}
}
return $self;
}
# deserialize non-array data
sub _deserialize {
my ($self, $type, $data) = @_;
$log->debugf("deserializing %s with %s",Dumper($data), $type);
if ($type eq 'DateTime') {
return DateTime->from_epoch(epoch => str2time($data));
} elsif ( grep( /^$type$/, ('int', 'double', 'string', 'boolean'))) {
return $data;
} else { # hash(model)
my $_instance = eval "EzmaxApi::Object::$type->new()";
return $_instance->from_hash($data);
}
}
__PACKAGE__->class_documentation({description => 'Response for POST /1/object/ezsignbulksenddocumentmapping',
class => 'EzsignbulksenddocumentmappingCreateObjectV1Response',
required => [], # TODO
} );
__PACKAGE__->method_documentation({
'm_payload' => {
datatype => 'EzsignbulksenddocumentmappingCreateObjectV1ResponseMPayload',
base_name => 'mPayload',
description => '',
format => '',
read_only => '',
},
'obj_debug_payload' => {
datatype => 'CommonResponseObjDebugPayload',
base_name => 'objDebugPayload',
description => '',
format => '',
read_only => '',
},
'obj_debug' => {
datatype => 'CommonResponseObjDebug',
base_name => 'objDebug',
description => '',
format => '',
read_only => '',
},
});
__PACKAGE__->openapi_types( {
'm_payload' => 'EzsignbulksenddocumentmappingCreateObjectV1ResponseMPayload',
'obj_debug_payload' => 'CommonResponseObjDebugPayload',
'obj_debug' => 'CommonResponseObjDebug'
} );
__PACKAGE__->attribute_map( {
'm_payload' => 'mPayload',
'obj_debug_payload' => 'objDebugPayload',
'obj_debug' => 'objDebug'
} );
__PACKAGE__->mk_accessors(keys %{__PACKAGE__->attribute_map});
1;
| 28.376812 | 123 | 0.623766 |
ed62d551632edcd86655a0e8ddf8fb0a2bdcc52c | 2,468 | pm | Perl | auto-lib/Paws/StorageGateway/CancelArchival.pm | shogo82148/aws-sdk-perl | a87555a9d30dd1415235ebacd2715b2f7e5163c7 | [
"Apache-2.0"
] | null | null | null | auto-lib/Paws/StorageGateway/CancelArchival.pm | shogo82148/aws-sdk-perl | a87555a9d30dd1415235ebacd2715b2f7e5163c7 | [
"Apache-2.0"
] | 1 | 2021-05-26T19:13:58.000Z | 2021-05-26T19:13:58.000Z | auto-lib/Paws/StorageGateway/CancelArchival.pm | shogo82148/aws-sdk-perl | a87555a9d30dd1415235ebacd2715b2f7e5163c7 | [
"Apache-2.0"
] | null | null | null |
package Paws::StorageGateway::CancelArchival;
use Moose;
has GatewayARN => (is => 'ro', isa => 'Str', required => 1);
has TapeARN => (is => 'ro', isa => 'Str', required => 1);
use MooseX::ClassAttribute;
class_has _api_call => (isa => 'Str', is => 'ro', default => 'CancelArchival');
class_has _returns => (isa => 'Str', is => 'ro', default => 'Paws::StorageGateway::CancelArchivalOutput');
class_has _result_key => (isa => 'Str', is => 'ro');
1;
### main pod documentation begin ###
=head1 NAME
Paws::StorageGateway::CancelArchival - Arguments for method CancelArchival on L<Paws::StorageGateway>
=head1 DESCRIPTION
This class represents the parameters used for calling the method CancelArchival on the
L<AWS Storage Gateway|Paws::StorageGateway> service. Use the attributes of this class
as arguments to method CancelArchival.
You shouldn't make instances of this class. Each attribute should be used as a named argument in the call to CancelArchival.
=head1 SYNOPSIS
my $storagegateway = Paws->service('StorageGateway');
# To cancel virtual tape archiving
# Cancels archiving of a virtual tape to the virtual tape shelf (VTS) after
# the archiving process is initiated.
my $CancelArchivalOutput = $storagegateway->CancelArchival(
'GatewayARN' =>
'arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B',
'TapeARN' =>
'arn:aws:storagegateway:us-east-1:999999999999:tape/AMZN01A2A4'
);
# Results:
my $TapeARN = $CancelArchivalOutput->TapeARN;
# Returns a L<Paws::StorageGateway::CancelArchivalOutput> object.
Values for attributes that are native types (Int, String, Float, etc) can passed as-is (scalar values). Values for complex Types (objects) can be passed as a HashRef. The keys and values of the hashref will be used to instance the underlying object.
For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/storagegateway/CancelArchival>
=head1 ATTRIBUTES
=head2 B<REQUIRED> GatewayARN => Str
=head2 B<REQUIRED> TapeARN => Str
The Amazon Resource Name (ARN) of the virtual tape you want to cancel
archiving for.
=head1 SEE ALSO
This class forms part of L<Paws>, documenting arguments for method CancelArchival in L<Paws::StorageGateway>
=head1 BUGS and CONTRIBUTIONS
The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
=cut
| 31.641026 | 249 | 0.726499 |
edbd8b9c1de6f3d878b387229ea09e3a7dc02c71 | 6,851 | pl | Perl | test/smoke-tests/crux-test.pl | austinkeller/crux-toolkit | 9a35807ba24c3d8b22299f16accfd70286356212 | [
"Apache-2.0"
] | 27 | 2016-10-04T19:06:41.000Z | 2022-02-24T12:59:59.000Z | test/smoke-tests/crux-test.pl | austinkeller/crux-toolkit | 9a35807ba24c3d8b22299f16accfd70286356212 | [
"Apache-2.0"
] | 232 | 2016-10-25T05:54:38.000Z | 2022-03-30T20:33:35.000Z | test/smoke-tests/crux-test.pl | austinkeller/crux-toolkit | 9a35807ba24c3d8b22299f16accfd70286356212 | [
"Apache-2.0"
] | 29 | 2016-10-04T22:12:32.000Z | 2022-03-26T17:12:27.000Z | #!/usr/bin/perl -w
#
# Note: copied from Charles Grant's meme-test.pl
=head1 crux-test.pl
Usage: crux-test.pl [-up] <test list file>
The crux-test.pl script provides a framework for testing the overall
functionality of programs in the crux distribution. It read a list of
tests from a '='-delimited file, one test per line. Each test is described
by four fields:
=over 4
=item 0
a Boolean value (0 or 1) indicating whether the test should be run under a
Darwin OS
=item o
the name of the test
=item o
the path to the file containing the known good output
=item o
the command line implementing the test
=back
The command line for each test is executed with the STDOUT captured to
a file. STDERR is written as is. The test output is compared to the
known good output contained in the file specified in the second
field. If the test output matches the known good output, then the test
succeeds; otherwise, it fails. The results are printed to the standard
output. When a test fails, a copy of the observed output (with the
filename extension ".observed") is placed alongside the known good output
file.
If the '-u' option is specified, then the files containing the
known good output will be replaced by the output of the test.
It is assumed that the command to be tested sends its output to
standard out.
=cut
use strict;
use Getopt::Std;
use File::Temp qw/ tempfile tempdir /;
# Get the name of the architecture.
my $arch = `uname`;
print(STDERR "Running Crux smoke tests under $arch.\n");
# Handle the command line arguments.
my $usage = "Usage: crux-test.pl [-up] <file name>\n";
my (%options, $update);
if (!getopts('up:', \%options)) {
die($usage);
};
if (scalar @ARGV != 1) {
die("Incorrect number of arguments.\n", $usage);
}
if (defined $options{'u'}) {
$update = 1;
} else {
$update = 0;
}
if( defined $options{'p'}){
my $path = $options{'p'};
$ENV{'PATH'} = $path . ":" . $ENV{'PATH'};
print "Prepended to PATH $path\n";
}
# Set an interrupt handler
my $caught_interrupt = 0;
$SIG{'INT'} = 'sigint_handler';
# Read each test from the file and execute it.
my $ignore_string = "";
my $num_tests = 0;
my $num_successful_tests = 0;
while (my $line = <ARGV>) {
if ($caught_interrupt) {
die("Testing was interrupted.");
}
# Skip comments and blank lines
next if $line =~ /^\#/;
next if $line =~ /^\s*$/;
# Parse the test parameters
chomp $line;
my @fields = split "=", $line;
my $do_darwin = $fields[0];
my $test_name = $fields[1];
my $standard_filename = $fields[2];
my $cmd = $fields[3];
$cmd =~ s/^ //;
$ignore_string = $fields[4];
# Remove whitespace from the filename.
$standard_filename =~ s/ //g;
# Skip this test if we're on a Darwin OS and it doesn't pass there.
if (($arch eq "Darwin\n") && ($do_darwin == "0")) {
print "\n----- Skipping test $test_name \n";
print STDERR "\n----- Skipping test $test_name \n";
next;
}
# Execute the test
print "\n----- Running test $test_name \n";
print STDERR "\n----- Running test $test_name \n";
my ($output_fh, $output_filename) = tempfile();
if (!$output_filename) {
die("Unable to create output file.\n");
}
my $result = &test_cmd($cmd, $standard_filename,
$output_filename, $ignore_string);
$num_tests++;
if ($result == 0) {
print "----- SUCCESS - test $test_name\n";
$num_successful_tests++;
} else {
print "----- FAILURE - test $test_name\n";
}
# Clean up
close $output_fh;
if ($update) {
# If the update flag was given replace the existing standard
# with the current test ouput.
system("cp $output_filename $standard_filename");
}
unlink $output_filename;
}
# Print the summary of the tests.
print "\n-------------------------------\n";
print "----- Successful Tests: $num_successful_tests\n";
my $num_failed_tests = $num_tests - $num_successful_tests;
print "----- Failed Tests: $num_failed_tests\n";
print "----- Total Tests: $num_tests\n";
print "-------------------------------\n\n";
exit($num_failed_tests);
=head2 test_cmd($cmd, $standard_filename, $output_filename, $ignore_string)
Arguments:
$cmd A string containing a shell command to execute.
$standard_filename The name of a file containing the expected ouput
for the shell command.
$output_filename The name of the file used to store the output of the
command.
$ignore_string A string of regexes to be ignored by diff, each regex
in single quotes separated by a space. eg 'H' 'Time ex'
The test_cmd function executes the command line passed in the $cmd variable
storing the output in $output_filename. If the return status indicates the
command was successful the output of the command is compared to the expected
output as stored in $standard_filename using diff. If there are differences
the output of diff is sent to standard out.
Returns 0 if the command executed successfully and the output exactly matched
the expected output, 1 otherwise.
=cut
sub test_cmd() {
my ($cmd, $standard_filename, $output_filename, $ignore_string) = @_;
my ($diff_fh, $diff_filename) = tempfile();
if (!$diff_filename) {
die("unable to create diff file.\n");
}
$cmd .= " > $output_filename";
my $result = system($cmd);
if ($result == 0) {
# The command was successful, now vet the output.
if( $ignore_string ){
$ignore_string =~ s/ \'/ -I \'/g; #add -I to each regex
}else{
$ignore_string = " ";
}
my $diff_cmd = "diff $ignore_string $standard_filename $output_filename" .
"> $diff_filename";
$result = system($diff_cmd);
if ($result == 0) {
# The output of the command matches the expected output.
} else {
# The output of the command doesn't match the expected output.
# Store a copy of the observed output.
my $copy_command = "cp $output_filename $standard_filename.observed";
print("$copy_command\n");
system($copy_command);
# Print the diff output.
open(DIFF, $diff_filename) || die("Unable to read diff file.\n");
my $diff_line;
while ($diff_line = <DIFF>) {
print $diff_line;
}
close DIFF;
# Also check to see which columns changed.
$diff_cmd = "./compare-by-field.pl $standard_filename $output_filename" .
"> $diff_filename" ;
system($diff_cmd);
print "Compare by field results\n";
open(DIFF, $diff_filename) || die("Unable to read diff file.\n");
while ($diff_line = <DIFF>) {
print $diff_line;
}
close DIFF;
unlink $diff_filename;
}
} else {
# The command was not succesful
die("Testing failed.");
}
return $result;
}
sub sigint_handler {
$caught_interrupt = 1;
}
| 28.427386 | 79 | 0.64881 |
73d359faa7043edb4d9c33b97b79112f735918c3 | 3,970 | pm | Perl | notification/foxbox/mode/alert.pm | petneli/centreon-plugins | d131e60a1859fdd0e959623de56e6e7512c669af | [
"Apache-2.0"
] | 316 | 2015-01-18T20:37:21.000Z | 2022-03-27T00:20:35.000Z | notification/foxbox/mode/alert.pm | petneli/centreon-plugins | d131e60a1859fdd0e959623de56e6e7512c669af | [
"Apache-2.0"
] | 2,333 | 2015-04-26T19:10:19.000Z | 2022-03-31T15:35:21.000Z | notification/foxbox/mode/alert.pm | petneli/centreon-plugins | d131e60a1859fdd0e959623de56e6e7512c669af | [
"Apache-2.0"
] | 371 | 2015-01-18T20:37:23.000Z | 2022-03-22T10:10:16.000Z | #
# Copyright 2021 Centreon (http://www.centreon.com/)
#
# Centreon is a full-fledged industry-strength solution that meets
# the needs in IT infrastructure and application monitoring for
# service performance.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
package notification::foxbox::mode::alert;
use base qw(centreon::plugins::mode);
use strict;
use warnings;
use centreon::plugins::http;
sub new {
my ($class, %options) = @_;
my $self = $class->SUPER::new(package => __PACKAGE__, %options);
bless $self, $class;
$options{options}->add_options(arguments => {
"foxbox-username:s" => { name => 'foxbox_username', default => 'centreon' },
"foxbox-password:s" => { name => 'foxbox_password' },
"from:s" => { name => 'from', default => 'centreon' },
"proto:s" => { name => 'proto', default => 'http' },
"urlpath:s" => { name => 'url_path', default => '/source/send_sms.php' },
"phonenumber:s" => { name => 'phonenumber' },
"hostname:s" => { name => 'hostname' },
"texto:s" => { name => 'texto' },
"timeout:s" => { name => 'timeout', default => 10 },
});
$self->{http} = centreon::plugins::http->new(%options);
return $self;
}
sub check_options {
my ($self, %options) = @_;
$self->SUPER::init(%options);
if (!defined($self->{option_results}->{foxbox_password})) {
$self->{output}
->add_option_msg(short_msg => "You need to set --foxbox-username and --foxbox-password options");
$self->{output}->option_exit();
}
if (!defined($self->{option_results}->{phonenumber})) {
$self->{output}->add_option_msg(short_msg => "Please set the --phonenumber option");
$self->{output}->option_exit();
}
if (!defined($self->{option_results}->{texto})) {
$self->{output}->add_option_msg(short_msg => "Please set the --texto option");
$self->{output}->option_exit();
}
$self->{http}->set_options(%{ $self->{option_results} });
}
sub run {
my ($self, %options) = @_;
my $response = $self->{http}->request(method => 'POST',
post_param => [
'username=' . $self->{option_results}->{foxbox_username},
'pwd=' . $self->{option_results}->{foxbox_password},
'from=' . $self->{option_results}->{from},
'nphone=' . $self->{option_results}->{phonenumber},
'testo=' . $self->{option_results}->{texto},
]
);
$self->{output}->output_add(
severity => 'OK',
short_msg => 'message sent'
);
$self->{output}->display();
$self->{output}->exit();
}
1;
__END__
=head1 MODE
Send SMS with Foxbox API.
=over 8
=item B<--hostname>
url of the Foxbox Server.
=item B<--urlpath>
The url path. (Default: /source/send_sms.php)
=item B<--foxbox-username>
Specify username for API authentification (Default: centreon).
=item B<--foxbox-password>
Specify password for API authentification (Required).
=item B<--proto>
Specify http or https protocol. (Default: http)
=item B<--phonenumber>
Specify phone number (Required).
=item B<--texto>
Specify the content of your SMS message (Required).
=item B<--from>
Specify the sender. It should NOT start with a number and have a max of 11 characters (Default: centreon).
=item B<--timeout>
Timeout in seconds for the command (Default: 10).
=back
=cut
| 27.762238 | 109 | 0.613854 |
ed6f73f32d992a5cbbc2fdb9c88418f69e26fbdb | 591 | pm | Perl | lib/SemanticWeb/Schema/MedicalImagingTechnique.pm | robrwo/LDF-JSON-LD | 2745fa73562625ab217b7094a812bfc1f4be8cbc | [
"ClArtistic"
] | null | null | null | lib/SemanticWeb/Schema/MedicalImagingTechnique.pm | robrwo/LDF-JSON-LD | 2745fa73562625ab217b7094a812bfc1f4be8cbc | [
"ClArtistic"
] | null | null | null | lib/SemanticWeb/Schema/MedicalImagingTechnique.pm | robrwo/LDF-JSON-LD | 2745fa73562625ab217b7094a812bfc1f4be8cbc | [
"ClArtistic"
] | null | null | null | use utf8;
package SemanticWeb::Schema::MedicalImagingTechnique;
# ABSTRACT: Any medical imaging modality typically used for diagnostic purposes
use Moo;
extends qw/ SemanticWeb::Schema::MedicalEnumeration /;
use MooX::JSON_LD 'MedicalImagingTechnique';
use Ref::Util qw/ is_plain_hashref /;
# RECOMMEND PREREQ: Ref::Util::XS
use namespace::autoclean;
our $VERSION = 'v14.0.1';
=encoding utf8
=head1 DESCRIPTION
Any medical imaging modality typically used for diagnostic purposes.
Enumerated type.
=cut
=head1 SEE ALSO
L<SemanticWeb::Schema::MedicalEnumeration>
=cut
1;
| 14.071429 | 79 | 0.764805 |
edbba47ff13dd62ff60fc68458d208f6349e7cc2 | 3,570 | pm | Perl | lib/MooseX/Singleton.pm | git-the-cpan/MooseX-Singleton | fa9c0027023685b4d35333cc3d5557570d305cdc | [
"Artistic-1.0"
] | null | null | null | lib/MooseX/Singleton.pm | git-the-cpan/MooseX-Singleton | fa9c0027023685b4d35333cc3d5557570d305cdc | [
"Artistic-1.0"
] | null | null | null | lib/MooseX/Singleton.pm | git-the-cpan/MooseX-Singleton | fa9c0027023685b4d35333cc3d5557570d305cdc | [
"Artistic-1.0"
] | null | null | null | package MooseX::Singleton;
BEGIN {
$MooseX::Singleton::AUTHORITY = 'cpan:SARTAK';
}
{
$MooseX::Singleton::VERSION = '0.29';
}
use Moose 1.10 ();
use Moose::Exporter;
use MooseX::Singleton::Role::Object;
use MooseX::Singleton::Role::Meta::Class;
use MooseX::Singleton::Role::Meta::Instance;
Moose::Exporter->setup_import_methods( also => 'Moose' );
sub init_meta {
shift;
my %p = @_;
Moose->init_meta(%p);
my $caller = $p{for_class};
Moose::Util::MetaRole::apply_metaroles(
for => $caller,
class_metaroles => {
class => ['MooseX::Singleton::Role::Meta::Class'],
instance =>
['MooseX::Singleton::Role::Meta::Instance'],
constructor =>
['MooseX::Singleton::Role::Meta::Method::Constructor'],
},
);
Moose::Util::MetaRole::apply_base_class_roles(
for_class => $caller,
roles =>
['MooseX::Singleton::Role::Object'],
);
return $caller->meta();
}
1;
# ABSTRACT: turn your Moose class into a singleton
=pod
=head1 NAME
MooseX::Singleton - turn your Moose class into a singleton
=head1 VERSION
version 0.29
=head1 SYNOPSIS
package MyApp;
use MooseX::Singleton;
has env => (
is => 'rw',
isa => 'HashRef[Str]',
default => sub { \%ENV },
);
package main;
delete MyApp->env->{PATH};
my $instance = MyApp->instance;
my $same = MyApp->instance;
=head1 DESCRIPTION
A singleton is a class that has only one instance in an application.
C<MooseX::Singleton> lets you easily upgrade (or downgrade, as it were) your
L<Moose> class to a singleton.
All you should need to do to transform your class is to change C<use Moose> to
C<use MooseX::Singleton>. This module uses metaclass roles to do its magic, so
it should cooperate with most other C<MooseX> modules.
=head1 METHODS
A singleton class will have the following additional methods:
=head2 Singleton->instance
This returns the singleton instance for the given package. This method does
I<not> accept any arguments. If the instance does not yet exist, it is created
with its defaults values. This means that if your singleton requires
arguments, calling C<instance> will die if the object has not already been
initialized.
=head2 Singleton->initialize(%args)
This method can be called I<only once per class>. It explicitly initializes
the singleton object with the given arguments.
=head2 Singleton->_clear_instance
This clears the existing singleton instance for the class. Obviously, this is
meant for use only inside the class itself.
=head2 Singleton->new
This method currently works like a hybrid of C<initialize> and
C<instance>. However, calling C<new> directly will probably be deprecated in a
future release. Instead, call C<initialize> or C<instance> as appropriate.
=head1 BUGS
Please report any bugs or feature requests to
C<[email protected]>, or through the web interface at
L<http://rt.cpan.org>. We will be notified, and then you'll automatically be
notified of progress on your bug as we make changes.
=head1 SOME CODE STOLEN FROM
Anders Nor Berle E<lt>[email protected]<gt>
=head1 AND PATCHES FROM
Ricardo SIGNES E<lt>[email protected]<gt>
=head1 AUTHOR
Shawn M Moore <[email protected]>
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2011 by Shawn M Moore.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
__END__
| 23.8 | 78 | 0.695238 |
73d6cf61ff0995248ac974bcf30f529911527f4d | 5,315 | pl | Perl | scripts/dev/ring_dial.pl | ringmail/ringmail-backend | f2f418bc3d2d665961549fa3ff0b831dceed8d77 | [
"MIT"
] | null | null | null | scripts/dev/ring_dial.pl | ringmail/ringmail-backend | f2f418bc3d2d665961549fa3ff0b831dceed8d77 | [
"MIT"
] | null | null | null | scripts/dev/ring_dial.pl | ringmail/ringmail-backend | f2f418bc3d2d665961549fa3ff0b831dceed8d77 | [
"MIT"
] | null | null | null | #!/usr/bin/perl
use strict;
use warnings;
no warnings qw(uninitialized);
our $session;
our $env;
package Dialer;
use strict;
use warnings;
use MIME::Base64;
use JSON::XS;
use Net::RabbitMQ;
use Data::Dumper;
use Digest::MD5 'md5_hex';
use IO::All;
use URI::Encode 'uri_encode';
use LWP::UserAgent;
sub new
{
my ($class) = @_;
my $dataenc = $session->getVariable('rgm_data');
$session->setVariable('rgm_data', ''); # clear out the value
my $data = decode_json(decode_base64($dataenc));
#$session->setVariable('rgm_request', $data->{'request'});
my $uuid = $session->getVariable('uuid');
$data->{'uuid'} = $uuid;
# open(F, '/usr/local/freeswitch/scripts/config.njs') or do {
# freeswitch::consoleLog("ERR", "Error[$uuid]: Unable to open config file: $!\n");
# goto DONE;
# };
# local $/;
# my $cfg = <F>;
# close(F);
freeswitch::consoleLog("INFO", "Start[$uuid]: ". Dumper($data));
# $data->{'config'} = decode_json($cfg);
bless $data, $class;
return $data;
}
sub prompt
{
my ($obj) = @_;
$session->execute('sleep', '500');
foreach my $i (1..3)
{
$obj->say('press one to call this email');
my $dtmf = new freeswitch::EventConsumer('DTMF');
foreach my $i (1..20)
{
my $d = undef;
$session->setVariable('pressed', '');
$session->execute("play_and_get_digits", "1 1 1 2000 '' silence_stream://250 silence_stream://250 pressed .");
my $res = $session->getVariable('pressed');
if ($res eq '1')
{
return $obj->dial_attempt();
}
exit_on_hangup();
}
}
freeswitch::consoleLog("INFO", "End[$obj->{'uuid'}]\n");
}
sub dial_attempt
{
my ($obj) = @_;
$session->setVariable('instant_ringback', 'true');
$session->setVariable('continue_on_fail', 'false');
$session->setVariable('hangup_after_bridge', 'true');
$session->setVariable('call_timeout', '45');
$session->setVariable('transfer_ringback', '%(2000,4000,440,480)');
my $cid = '1'. $obj->{'did_number'}; # caller
my $cidname = $obj->{'did_number'}; # caller
$session->execute('bridge', "{origination_caller_id_number=$cid,origination_caller_id_name='$cidname'}". $obj->{'route'});
}
sub send_event
{
my ($obj, $event, $data) = @_;
freeswitch::consoleLog("INFO", "Dialer[$obj->{'uuid'}]: Send Event: $event\n");
#freeswitch::consoleLog("INFO", "Dialer[$obj->{'uuid'}]: Send Event: $event ". Dumper($data));
unless (defined $obj->{'rabbitmq'})
{
#my $rbcfg = $obj->{'config'}->{'rabbitmq'};
my $rbcfg = {
'host' => 'guest',
'user' => 'guest',
'password' => 'guest',
'port' => 5673,
};
$obj->{'rabbitmq'} = new Net::RabbitMQ();
$obj->{'rabbitmq'}->connect($rbcfg->{'host'}, {'user' => $rbcfg->{'user'}, 'password' => $rbcfg->{'password'}, 'port' => $rbcfg->{'port'}});
$obj->{'rabbitmq'}->channel_open(1);
}
my $rbq = $obj->{'rabbitmq'};
$data->{'uuid'} = $obj->{'uuid'};
$data->{'hostname'} = $obj->{'hostname'};
my $json = encode_json([$event, $data]);
$rbq->publish(1, 'rgm_dialer', $json, {'exchange' => 'ringmail'});
}
sub reply_wait
{
my ($obj, $secs, $loopfn) = @_;
my $r = '';
LOOP: foreach my $i (1..$secs)
{
foreach my $j (1..4)
{
exit_on_hangup();
$session->execute('sleep', '250');
$r = $session->getVariable('rgm_reply');
if (length($r))
{
last LOOP;
}
}
if (defined($loopfn) && ref($loopfn) eq 'CODE')
{
$loopfn->($obj, $secs, $i);
}
}
my $data = undef;
unless (length($r))
{
freeswitch::consoleLog("INFO", "Dialer[$obj->{'uuid'}]: Empty Reply\n");
}
eval {
$data = decode_json(decode_base64($r));
};
unless (defined $data)
{
freeswitch::consoleLog("INFO", "Dialer[$obj->{'uuid'}]: Bad Reply\n");
#warn("Bad reply data: $@");
return undef;
}
#else
#{
# freeswitch::consoleLog("INFO", "Dialer[$obj->{'uuid'}]: Got Reply: ". Dumper($data));
#}
return $data;
}
sub exit_on_hangup
{
my $st = $session->getState();
if ($st eq 'CS_HANGUP')
{
goto DONE;
}
}
sub say_google
{
my ($obj, $msg) = @_;
my $md5 = md5_hex($msg);
my $root = '/usr/local/freeswitch/sounds/en/us/callie/tts';
mkdir($root) unless (-d $root);
my $fp = $root. '/'. $md5. '.mp3';
unless (-e $fp)
{
my $url = 'http://translate.google.com/translate_tts?tl=en&q='. uri_encode($msg);
freeswitch::consoleLog("INFO", "Get $url -> $fp\n");
my $ua = new LWP::UserAgent(
'agent' => 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.0.6) Gecko/2009011912 Firefox/3.0.6',
);
my $r = $ua->get($url);
if ($r->is_success())
{
$r->content() > io($fp);
freeswitch::consoleLog("INFO", "Convert $fp\n");
my $wav = $fp;
$wav =~ s/mp3$/wav/;
my $wavtmp = $wav;
$wavtmp =~ s/\.wav$/_tmp.wav/;
my $wav2 = $wav;
$wav2 =~ s/\.wav$/_16.wav/;
system('/usr/local/bin/lame', '--decode', $fp, $wavtmp);
system('/usr/bin/sox', $wavtmp, '-c', 1, '-r', 8000, $wav);
system('/usr/bin/sox', $wavtmp, '-c', 1, '-r', 16000, $wav2);
unlink($wavtmp);
}
}
my $w2 = '';
my $ci = $session->getVariable('read_codec');
if ($ci ne 'PCMU')
{
$w2 = '_16';
}
my $play = 'tts/'. $md5. $w2. '.wav';
$session->execute('playback', $play);
}
sub say
{
my ($obj, $msg) = @_;
$obj->say_google($msg);
#$session->execute('speak', 'flite|kal|'. $msg);
}
1;
package main;
my $d = new Dialer();
$d->prompt();
DONE:
if (defined $d->{'rabbitmq'})
{
$d->{'rabbitmq'}->disconnect();
}
1;
| 24.159091 | 142 | 0.588147 |
edabccb931432439bd9cb50badd986ab47f174e2 | 4,854 | t | Perl | modules/t/gffParser.t | dbolser-ebi/ensembl | d60bb4562d2c82637a7befdee5a4ebe6b9795a3d | [
"Apache-2.0"
] | null | null | null | modules/t/gffParser.t | dbolser-ebi/ensembl | d60bb4562d2c82637a7befdee5a4ebe6b9795a3d | [
"Apache-2.0"
] | null | null | null | modules/t/gffParser.t | dbolser-ebi/ensembl | d60bb4562d2c82637a7befdee5a4ebe6b9795a3d | [
"Apache-2.0"
] | null | null | null | # Copyright [1999-2014] Wellcome Trust Sanger Institute and the EMBL-European Bioinformatics Institute
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
use strict;
use warnings;
use Test::More;
use IO::String;
use Bio::EnsEMBL::Utils::IO::GFFParser;
{
my $io = IO::String->new(<<'GFF');
##gff-version 3
##sequence-region ctg123 1 1497228
##taken-from http://www.sequenceontology.org/gff3.shtml
ctg123 . gene 1000 9000 . + . ID=gene00001;Name=EDEN
ctg123 . TF_binding_site 1000 1012 . + . ID=tfbs00001;Parent=gene00001
ctg123 . mRNA 1050 9000 . + . ID=mRNA00001;Parent=gene00001;Name=EDEN.1
ctg123 . mRNA 1050 9000 . + . ID=mRNA00002;Parent=gene00001;Name=EDEN.2
ctg123 . mRNA 1300 9000 . + . ID=mRNA00003;Parent=gene00001;Name=EDEN.3
ctg123 . exon 1300 1500 . + . ID=exon00001;Parent=mRNA00003
ctg123 . exon 1050 1500 . + . ID=exon00002;Parent=mRNA00001,mRNA00002
ctg123 . exon 3000 3902 . + . ID=exon00003;Parent=mRNA00001,mRNA00003
ctg123 . exon 5000 5500 . + . ID=exon00004;Parent=mRNA00001,mRNA00002,mRNA00003
ctg123 . exon 7000 9000 . + . ID=exon00005;Parent=mRNA00001,mRNA00002,mRNA00003
ctg123 . CDS 1201 1500 . + 0 ID=cds00001;Parent=mRNA00001;Name=edenprotein.1
ctg123 . CDS 3000 3902 . + 0 ID=cds00001;Parent=mRNA00001;Name=edenprotein.1
ctg123 . CDS 5000 5500 . + 0 ID=cds00001;Parent=mRNA00001;Name=edenprotein.1
ctg123 . CDS 7000 7600 . + 0 ID=cds00001;Parent=mRNA00001;Name=edenprotein.1
GFF
my $gff = Bio::EnsEMBL::Utils::IO::GFFParser->new($io);
my $header = $gff->parse_header();
is_deeply(
$header,
[ '##gff-version 3', '##sequence-region ctg123 1 1497228', '##taken-from http://www.sequenceontology.org/gff3.shtml'],
'Checking headers all parse'
);
my $actual_gene = $gff->parse_next_feature();
my $expected_gene = {
seqid => 'ctg123', start => 1000, end => 9000, strand => 1,
source => '.', type => 'gene', score => '.', phase => '.',
attribute => { ID => 'gene00001', Name => 'EDEN' }
};
is_deeply($actual_gene, $expected_gene, 'Checking gene record parses');
my $actual_tf = $gff->parse_next_feature();
my $expected_tf = {
seqid => 'ctg123', start => 1000, end => 1012, strand => 1,
source => '.', type => 'TF_binding_site', score => '.', phase => '.',
attribute => { ID => 'tfbs00001', Parent => 'gene00001' }
};
is_deeply($actual_tf, $expected_tf, 'Checking TF record parses');
#SKIP TO EXONS
$gff->parse_next_feature(); #mrna
$gff->parse_next_feature(); #mrna
$gff->parse_next_feature(); #mrna
#EXONS
{
my $actual = $gff->parse_next_feature();
my $expected = {
seqid => 'ctg123', start => 1300, end => 1500, strand => 1,
source => '.', type => 'exon', score => '.', phase => '.',
attribute => { ID => 'exon00001', Parent => 'mRNA00003' }
};
is_deeply($actual, $expected, 'Checking Exon 1 record parses');
}
{
my $actual = $gff->parse_next_feature();
my $expected = {
seqid => 'ctg123', start => 1050, end => 1500, strand => 1,
source => '.', type => 'exon', score => '.', phase => '.',
attribute => { ID => 'exon00002', Parent => ['mRNA00001', 'mRNA00002'] }
};
is_deeply($actual, $expected, 'Checking Exon 2 record parses');
}
}
{
my $string = <<GFF;
##gff-version 3
##sequence-region ctg123 1 1497228
##taken-from example parsing file with FASTA directive
ctg123\t.\tgene\t1000\t9000\t.\t+\t.\tID=gene00001;Name=EDEN
###
##FASTA
>ctg123
AACCTTTGGGCCGGGCCTTAAAA
AACC
GFF
my $io = IO::String->new(\$string);
my $gff = Bio::EnsEMBL::Utils::IO::GFFParser->new($io);
my $header = $gff->parse_header();
is_deeply(
$header,
[ '##gff-version 3', '##sequence-region ctg123 1 1497228', '##taken-from example parsing file with FASTA directive'],
'Checking headers all parse'
);
my $actual_gene = $gff->parse_next_feature();
my $expected_gene = {
seqid => 'ctg123', start => 1000, end => 9000, strand => 1,
source => '.', type => 'gene', score => '.', phase => '.',
attribute => { ID => 'gene00001', Name => 'EDEN' }
};
is_deeply($actual_gene, $expected_gene, 'Checking TF record parses');
my $id = $gff->parse_next_feature();
ok(! defined $id, 'No more features');
my $seq = $gff->parse_next_sequence();
is_deeply($seq, {header => '>ctg123', sequence => "AACCTTTGGGCCGGGCCTTAAAAAACC"}, "Checking Sequence parses correctly")
}
done_testing();
| 37.053435 | 123 | 0.663782 |
edcf1acd28c917143c0e773ad76f7bcd4d65d88c | 979 | pl | Perl | cmd/set/register.pl | latchdevel/DXspider | e61ab5eeea22241ea8d8f1f6d072f5249901d788 | [
"Artistic-1.0-Perl",
"Artistic-2.0"
] | null | null | null | cmd/set/register.pl | latchdevel/DXspider | e61ab5eeea22241ea8d8f1f6d072f5249901d788 | [
"Artistic-1.0-Perl",
"Artistic-2.0"
] | null | null | null | cmd/set/register.pl | latchdevel/DXspider | e61ab5eeea22241ea8d8f1f6d072f5249901d788 | [
"Artistic-1.0-Perl",
"Artistic-2.0"
] | null | null | null | #
# register a user
#
# Copyright (c) 2001 Dirk Koopman G1TLH
#
#
#
my ($self, $line) = @_;
my @args = split /\s+/, $line;
my $call;
# my $priv = shift @args;
my @out;
my $user;
my $ref;
if ($self->priv < 9) {
Log('DXCommand', $self->call . " attempted to register @args");
return (1, $self->msg('e5'));
}
#return (1, $self->msg('reginac')) unless $main::reqreg;
foreach $call (@args) {
$call = uc $call;
unless ($self->remotecmd || $self->inscript) {
if ($ref = DXUser::get_current($call)) {
$ref->registered(1);
$ref->put();
push @out, $self->msg("reg", $call);
} else {
$ref = DXUser->new($call);
$ref->registered(1);
$ref->put();
push @out, $self->msg("regc", $call);
}
my $dxchan = DXChannel::get($call);
$dxchan->registered(1) if $dxchan;
Log('DXCommand', $self->call . " registered $call");
} else {
Log('DXCommand', $self->call . " attempted to register $call remotely");
push @out, $self->msg('sorry');
}
}
return (1, @out);
| 22.25 | 74 | 0.578141 |
eda6f1f40020ceb6d1272686687493e4a5636deb | 4,821 | pm | Perl | lib/Zendesk.pm | scottmartin-code/zendesk-flatfile | fae322b0dd21d137b323ce7dd82fda4eec4b7c1b | [
"Artistic-2.0"
] | null | null | null | lib/Zendesk.pm | scottmartin-code/zendesk-flatfile | fae322b0dd21d137b323ce7dd82fda4eec4b7c1b | [
"Artistic-2.0"
] | null | null | null | lib/Zendesk.pm | scottmartin-code/zendesk-flatfile | fae322b0dd21d137b323ce7dd82fda4eec4b7c1b | [
"Artistic-2.0"
] | null | null | null | package Zendesk;
use warnings;
use strict;
use Encode 'encode_utf8';
use File::Slurper 'read_text';
use JSON;
use Sort::Naturally;
use Template;
use WWW::Mechanize;
sub new {
my $self = bless {}, shift;
my $args = shift;
$self->{$_} = $args->{$_} foreach qw(
attachments_dir custom_fields delay indices_dir quiet
resources_dir tickets_json_dir tickets_html_dir update
);
$self;
}
sub download_attachments {
my $self = shift;
my $index_file = $self->{indices_dir} . '/attachments.csv';
my $delay = $self->{delay};
my $index = read_text $index_file;
my @items = split "\n", $index;
my $current_item = 0;
my $total_items = $#items;
my $mech = WWW::Mechanize->new;
$self->status('Beginning attachment download process.');
foreach my $item (@items) {
my ($ticket_id, $file, $url) = $item =~ m((\d+)/(.*?)\t(.*?)$);
$file = encode_utf8 $file;
die "Attachments directory doesn't exist" unless -d $self->{attachments_dir};
my $dir = $self->{attachments_dir} . "/$ticket_id";
mkdir $dir unless -d $dir && -w $dir;
++$current_item;
my $a_ident = "Attachment [$current_item/$total_items]";
my $t_ident = "Ticket #$ticket_id - $file";
if (-f "$dir/$file" && !$self->{update}) {
$self->status("$a_ident found, skipping: $t_ident.", $self->{quiet});
next;
} else {
$self->status("$a_ident downloading: $t_ident.", $self->{quiet});
}
$mech->get($url);
die "Couldn't get file: HTTP " . $mech->status if !$mech->success;
open (my $out, '>', "$dir/$file") or die $!;
binmode $out;
print $out $mech->content;
close $out;
sleep $delay;
}
$self->status('Downloads complete.');
}
sub index_attachments {
my $self = shift;
my $indices_dir = $self->{indices_dir};
my $tickets_json_dir = $self->{tickets_json_dir};
$self->status('Beginning attachment indexing process.');
use open ":encoding(utf8)";
open (my $index, '>', "$indices_dir/attachments.csv") or die $!;
foreach (nsort(glob("$tickets_json_dir/*.json"))) {
my $json = encode_utf8 read_text $_;
my $ticket = decode_json $json;
my ($ticket_id) = $_ =~ m($tickets_json_dir/(\d+));
$self->status("Indexing attachments for ticket #$ticket_id.", $self->{quiet});
my $comment_number = 0;
foreach my $comment (@{$ticket->{comments}}) {
$comment->{comment_number} = ++$comment_number;
foreach my $file (@{$comment->{attachments}}) {
print $index "$ticket_id/" . $comment->{comment_number} . '_' . $file->{file_name};
print $index "\t" . $file->{content_url} . "\n";
}
}
}
close $index;
$self->status('Indexing complete.');
}
sub json_to_html {
my $self = shift;
my $tickets_json_dir = $self->{tickets_json_dir};
my $tickets_html_dir = $self->{tickets_html_dir};
my $resources_dir = $self->{resources_dir};
my $custom_fields = $self->{custom_fields};
$self->status('Beginning conversion process.');
foreach (nsort(glob("$tickets_json_dir/*.json"))) {
my ($ticket_id) = $_ =~ m($tickets_json_dir/(\d+));
if (-f "$tickets_html_dir/$ticket_id.html" && !$self->{update}) {
$self->status("Convert: found ticket #$ticket_id, skipping.", $self->{quiet});
next;
} else {
$self->status("Convert: converting ticket #$ticket_id.", $self->{quiet});
}
my $json = encode_utf8 read_text $_;
my $ticket = decode_json $json;
my $people; # ID => name
foreach (qw(submitter requester assignee)) {
if ($ticket->{$_}) {
$people->{$ticket->{$_}->{id}} = $ticket->{$_}->{name};
}
}
my $comment_number = 0;
# Additional data that simplifies the template
foreach (@{$ticket->{comments}}) {
$_->{comment_number} = ++$comment_number;
$_->{author} = $people->{$_->{author_id}};
}
Template->new->process(
"$resources_dir/ticket.tt",
{
ticket => $ticket,
custom_fields => $custom_fields,
},
"$tickets_html_dir/$ticket_id.html",
{ binmode => ':encoding(UTF-8)' }
) || die;
}
$self->status('Conversion complete.');
}
sub split_json {
my ($self, $file) = @_;
my $tickets_json_dir = $self->{tickets_json_dir};
my $json = read_text $file;
my @lines = split "\n", $json;
use open ":encoding(utf8)";
$self->status('Beginning dump file splitting process.');
foreach (@lines) {
my ($id) = $_ =~ /"id":(\d+),/;
if (-f "$tickets_json_dir/$id.json" && !$self->{update}) {
$self->status("Split: found ticket #$id, skipping.", $self->{quiet});
} else {
$self->status("Split: splitting ticket #$id.", $self->{quiet});
}
open (my $out, '>', "$tickets_json_dir/$id.json") or die $!;
print $out $_;
close $out;
}
$self->status('Split complete.');
}
sub skip {
my ($self, $process) = @_;
$self->status("Skipping $process process.");
}
sub status {
my ($self, $message, $quiet) = @_;
print "$message\n" unless $quiet;
}
1; | 23.632353 | 87 | 0.616677 |
ed8639a74bb79a61460860c49d5831b437379871 | 1,802 | pl | Perl | examples/demo-focus.pl | gitpan/Tickit | 6aa204da5938142f2fb3ce4096f4ffba7478bad7 | [
"Artistic-1.0"
] | null | null | null | examples/demo-focus.pl | gitpan/Tickit | 6aa204da5938142f2fb3ce4096f4ffba7478bad7 | [
"Artistic-1.0"
] | null | null | null | examples/demo-focus.pl | gitpan/Tickit | 6aa204da5938142f2fb3ce4096f4ffba7478bad7 | [
"Artistic-1.0"
] | null | null | null | #!/usr/bin/perl
use strict;
use warnings;
use Tickit;
use Tickit::Widgets qw( GridBox Frame HBox Entry Static Button CheckButton RadioButton );
Tickit::Style->load_style( <<'EOF' );
Entry:focus {
bg: "blue";
b: 1;
}
Frame {
linetype: "single";
}
Frame:focus-child {
frame-fg: "red";
}
CheckButton:focus {
check-bg: "blue";
}
RadioButton:focus {
tick-bg: "blue";
}
EOF
my $gridbox = Tickit::Widget::GridBox->new(
style => {
row_spacing => 1,
col_spacing => 2,
},
);
foreach my $row ( 0 .. 2 ) {
$gridbox->add( $row, 0, Tickit::Widget::Static->new( text => "Entry $row" ) );
$gridbox->add( $row, 1, Tickit::Widget::Entry->new, col_expand => 1 );
}
{
$gridbox->add( 3, 0, Tickit::Widget::Static->new( text => "Buttons" ) );
$gridbox->add( 3, 1, Tickit::Widget::Frame->new(
child => my $hbox = Tickit::Widget::HBox->new( spacing => 2 ),
) );
foreach my $label (qw( One Two Three )) {
$hbox->add( Tickit::Widget::Button->new( label => $label, on_click => sub {} ), expand => 1 );
}
}
{
$gridbox->add( 4, 0, Tickit::Widget::Static->new( text => "Checks" ) );
$gridbox->add( 4, 1, Tickit::Widget::Frame->new(
child => my $hbox = Tickit::Widget::HBox->new( spacing => 2 ),
) );
foreach ( 0 .. 2 ) {
$hbox->add( Tickit::Widget::CheckButton->new( label => "Check $_" ) );
}
}
{
$gridbox->add( 5, 0, Tickit::Widget::Static->new( text => "Radios" ) );
$gridbox->add( 5, 1, Tickit::Widget::Frame->new(
child => my $hbox = Tickit::Widget::HBox->new( spacing => 2 ),
) );
my $group = Tickit::Widget::RadioButton::Group->new;
foreach ( 0 .. 2 ) {
$hbox->add( Tickit::Widget::RadioButton->new( label => "Radio $_", group => $group ) );
}
}
Tickit->new( root => $gridbox )->run;
| 23.102564 | 100 | 0.566038 |
edd16f405594a7e0d25d479e7e04272679bf8061 | 3,385 | pl | Perl | Configurations/shared-info.pl | c4rlo/openssl | ec9135a62320c861ab17f7179ebe470686360c64 | [
"Apache-2.0"
] | 19,127 | 2015-01-01T18:26:43.000Z | 2022-03-31T21:50:00.000Z | Configurations/shared-info.pl | c4rlo/openssl | ec9135a62320c861ab17f7179ebe470686360c64 | [
"Apache-2.0"
] | 17,222 | 2015-01-04T19:36:01.000Z | 2022-03-31T23:50:53.000Z | Configurations/shared-info.pl | c4rlo/openssl | ec9135a62320c861ab17f7179ebe470686360c64 | [
"Apache-2.0"
] | 9,313 | 2015-01-01T21:37:44.000Z | 2022-03-31T23:08:27.000Z | #! /usr/bin/env perl
# -*- mode: perl; -*-
# Copyright 2016-2021 The OpenSSL Project Authors. All Rights Reserved.
#
# Licensed under the Apache License 2.0 (the "License"). You may not use
# this file except in compliance with the License. You can obtain a copy
# in the file LICENSE in the source distribution or at
# https://www.openssl.org/source/license.html
# This is a collection of extra attributes to be used as input for creating
# shared libraries, currently on any Unix variant, including Unix like
# environments on Windows.
sub detect_gnu_ld {
my @lines =
`$config{CROSS_COMPILE}$config{CC} -Wl,-V /dev/null 2>&1`;
return grep /^GNU ld/, @lines;
}
sub detect_gnu_cc {
my @lines =
`$config{CROSS_COMPILE}$config{CC} -v 2>&1`;
return grep /gcc/, @lines;
}
my %shared_info;
%shared_info = (
'gnu-shared' => {
shared_ldflag => '-shared -Wl,-Bsymbolic',
shared_sonameflag => '-Wl,-soname=',
},
'linux-shared' => sub {
return {
%{$shared_info{'gnu-shared'}},
shared_defflag => '-Wl,--version-script=',
dso_ldflags =>
(grep /(?:^|\s)-fsanitize/,
@{$config{CFLAGS}}, @{$config{cflags}})
? ''
: '-Wl,-z,defs',
};
},
'bsd-gcc-shared' => sub { return $shared_info{'linux-shared'}; },
'darwin-shared' => {
module_ldflags => '-bundle',
shared_ldflag => '-dynamiclib -current_version $(SHLIB_VERSION_NUMBER) -compatibility_version $(SHLIB_VERSION_NUMBER)',
shared_sonameflag => '-install_name $(libdir)/',
},
'cygwin-shared' => {
shared_ldflag => '-shared -Wl,--enable-auto-image-base',
shared_impflag => '-Wl,--out-implib=',
},
'mingw-shared' => sub {
return {
%{$shared_info{'cygwin-shared'}},
# def_flag made to empty string so it still generates
# something
shared_defflag => '',
shared_argfileflag => '@',
};
},
'alpha-osf1-shared' => sub {
return $shared_info{'gnu-shared'} if detect_gnu_ld();
return {
module_ldflags => '-shared -Wl,-Bsymbolic',
shared_ldflag => '-shared -Wl,-Bsymbolic -set_version $(SHLIB_VERSION_NUMBER)',
};
},
'svr3-shared' => sub {
return $shared_info{'gnu-shared'} if detect_gnu_ld();
return {
shared_ldflag => '-G',
shared_sonameflag => '-h ',
};
},
'svr5-shared' => sub {
return $shared_info{'gnu-shared'} if detect_gnu_ld();
return {
shared_ldflag => detect_gnu_cc() ? '-shared' : '-G',
shared_sonameflag => '-h ',
};
},
'solaris-gcc-shared' => sub {
return $shared_info{'linux-shared'} if detect_gnu_ld();
return {
# Note: we should also have -shared here, but because some
# config targets define it with an added -static-libgcc
# following it, we don't want to change the order. This
# forces all solaris gcc config targets to define shared_ldflag
shared_ldflag => '-Wl,-Bsymbolic',
shared_defflag => "-Wl,-M,",
shared_sonameflag => "-Wl,-h,",
};
},
);
| 35.631579 | 135 | 0.548006 |
edaa392e7e9592940bbba4fd6c9eeaf07eee088b | 2,805 | pm | Perl | auto-lib/Paws/GameLift/FleetCapacity.pm | galenhuntington/aws-sdk-perl | 13b775dcb5f0b3764f0a82f3679ed5c7721e67d3 | [
"Apache-2.0"
] | null | null | null | auto-lib/Paws/GameLift/FleetCapacity.pm | galenhuntington/aws-sdk-perl | 13b775dcb5f0b3764f0a82f3679ed5c7721e67d3 | [
"Apache-2.0"
] | null | null | null | auto-lib/Paws/GameLift/FleetCapacity.pm | galenhuntington/aws-sdk-perl | 13b775dcb5f0b3764f0a82f3679ed5c7721e67d3 | [
"Apache-2.0"
] | null | null | null | package Paws::GameLift::FleetCapacity;
use Moose;
has FleetId => (is => 'ro', isa => 'Str');
has InstanceCounts => (is => 'ro', isa => 'Paws::GameLift::EC2InstanceCounts');
has InstanceType => (is => 'ro', isa => 'Str');
1;
### main pod documentation begin ###
=head1 NAME
Paws::GameLift::FleetCapacity
=head1 USAGE
This class represents one of two things:
=head3 Arguments in a call to a service
Use the attributes of this class as arguments to methods. You shouldn't make instances of this class.
Each attribute should be used as a named argument in the calls that expect this type of object.
As an example, if Att1 is expected to be a Paws::GameLift::FleetCapacity object:
$service_obj->Method(Att1 => { FleetId => $value, ..., InstanceType => $value });
=head3 Results returned from an API call
Use accessors for each attribute. If Att1 is expected to be an Paws::GameLift::FleetCapacity object:
$result = $service_obj->Method(...);
$result->Att1->FleetId
=head1 DESCRIPTION
Information about the fleet's capacity. Fleet capacity is measured in
EC2 instances. By default, new fleets have a capacity of one instance,
but can be updated as needed. The maximum number of instances for a
fleet is determined by the fleet's instance type.
Fleet-related operations include:
=over
=item *
CreateFleet
=item *
ListFleets
=item *
DeleteFleet
=item *
Describe fleets:
=over
=item *
DescribeFleetAttributes
=item *
DescribeFleetCapacity
=item *
DescribeFleetPortSettings
=item *
DescribeFleetUtilization
=item *
DescribeRuntimeConfiguration
=item *
DescribeEC2InstanceLimits
=item *
DescribeFleetEvents
=back
=item *
Update fleets:
=over
=item *
UpdateFleetAttributes
=item *
UpdateFleetCapacity
=item *
UpdateFleetPortSettings
=item *
UpdateRuntimeConfiguration
=back
=item *
Manage fleet actions:
=over
=item *
StartFleetActions
=item *
StopFleetActions
=back
=back
=head1 ATTRIBUTES
=head2 FleetId => Str
Unique identifier for a fleet.
=head2 InstanceCounts => L<Paws::GameLift::EC2InstanceCounts>
Current status of fleet capacity.
=head2 InstanceType => Str
Name of an EC2 instance type that is supported in Amazon GameLift. A
fleet instance type determines the computing resources of each instance
in the fleet, including CPU, memory, storage, and networking capacity.
Amazon GameLift supports the following EC2 instance types. See Amazon
EC2 Instance Types (http://aws.amazon.com/ec2/instance-types/) for
detailed descriptions.
=head1 SEE ALSO
This class forms part of L<Paws>, describing an object used in L<Paws::GameLift>
=head1 BUGS and CONTRIBUTIONS
The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
=cut
| 16.30814 | 102 | 0.744029 |
edbacfd789060c168800aa33b9b7aa95414b9464 | 915 | t | Perl | t/sandbox/01-memory.t | mamod/JavaScript-Duktape | 9d6175837b11d3bc469c61cd2410099a384da2a4 | [
"MIT"
] | 7 | 2015-05-14T06:49:44.000Z | 2018-05-22T00:36:24.000Z | t/sandbox/01-memory.t | mamod/JavaScript-Duktape | 9d6175837b11d3bc469c61cd2410099a384da2a4 | [
"MIT"
] | 17 | 2015-05-14T06:49:34.000Z | 2018-10-28T09:28:53.000Z | t/sandbox/01-memory.t | mamod/JavaScript-Duktape | 9d6175837b11d3bc469c61cd2410099a384da2a4 | [
"MIT"
] | 5 | 2015-05-17T16:04:16.000Z | 2017-03-10T18:44:56.000Z | use lib './lib';
use strict;
use warnings;
use JavaScript::Duktape;
use Data::Dumper;
use Test::More;
my $js = JavaScript::Duktape->new( max_memory => 256 * 1024 );
my $duk = $js->duk;
eval {
$duk->eval_string(q{
var str = '';
var n = 1;
while(1){
var x = new Buffer(++n * 5);
}
});
};
ok $@ =~ /alloc failed/;
$duk->peval_string(q{
var str = '';
print(n);
while(1){
// n is the previous size so we should fail immediately
var x = new Buffer(++n * 5);
throw new Error('not reached');
}
});
ok $duk->safe_to_string(-1) =~ /alloc failed/;
$duk->peval_string(q{
var str = '';
n = 1;
while(1){
// we reset n so buffer small and should not fail
var x = new Buffer(++n * 100);
throw new Error('should fail here');
}
});
ok $duk->safe_to_string(-1) =~ /fail here/;
done_testing();
| 19.0625 | 63 | 0.530055 |
73d9b27cf2255bbeb35cf0e4c39da4789d5b487b | 4,799 | pm | Perl | data/Expr/Formula.pm | crislanarafael/AItegral-model | fa126028dd039114610686f7fc88ab3b98a90fe3 | [
"Apache-2.0"
] | 1 | 2021-06-10T01:21:22.000Z | 2021-06-10T01:21:22.000Z | data/Expr/Formula.pm | crislanarafael/AItegral-model | fa126028dd039114610686f7fc88ab3b98a90fe3 | [
"Apache-2.0"
] | 9 | 2021-06-09T23:36:00.000Z | 2021-06-28T13:25:30.000Z | data/Expr/Formula.pm | crislanarafael/AItegral-model | fa126028dd039114610686f7fc88ab3b98a90fe3 | [
"Apache-2.0"
] | 1 | 2021-06-28T03:38:33.000Z | 2021-06-28T03:38:33.000Z | =head1 Formula
Formula package : a package for encapsulating data and functions
related to symbolic formulas and their manipulation.
=cut
package Formula;
# non relative imports from /usr/bin/perl
use strict;
use warnings;
# relative imports from current directory
sub testLoad{
print "Formula package successfully loaded!\n";
return 1;
}
=head1 Formula
Constructor for formula object:
@param class Object<Name>: the class name
@param data <String>: the formula
=cut
sub new {
my $class = shift();
my $vars = shift();
my $consts = shift();
my $data = shift();
my $nesting = shift();
if(!defined($vars) || !defined($consts) || !defined($data)){
die "Expected defined vars,consts and data for Formula Object\n";
}
if(! defined($nesting)){
$nesting = 1;
}
my $self = {
_vars => $vars,
_consts => $consts,
_data => $data,
_nesting => $nesting
};
bless $self, $class;
return $self;
}
=head1 getVars
Method for formula object that returns the variables for the formula
@returns <String>: variables in the formula object
=cut
sub getVars{
my ($self) = @_;
return $self ->{_vars};
}
=head1 getConsts
Method for formula object that returns the constants for the formula
@returns <String>: constants in the formula object
=cut
sub getConsts{
my ($self) = @_;
return $self -> {_consts};
}
=head1 getData
Method for formula object that returns the "data" for the formula
@returns <String>: the actual symbolic information of
=cut
sub getData{
my ($self) = @_;
return $self -> {_data};
}
=head1 getNesting
Method for formula object that returns the nesting parameter of
the formula. Useful as a hyperparameter.
=cut
sub getNesting{
my ($self) = @_;
return $self -> {_nesting};
}
=head1 isValid
Method for formula object that checks if the formula is indeed valid,
according to the following criteria:
- No two consecutive variable/constants
- No alphabetical strings that don't match builtin functions
-
@returns <bool> : True if formula is valid OR False is formula is invalid
=cut
sub isValid{
my ($self) = @_;
#TODO: IMPLEMENT using symbolic operator stacks
return 0;
}
#=========== "static" package functions ==============
=head1 getOperators
returns valid operators for symbolic formulas
@returns Array<String> : valid operators for symbolic formulas
=cut
sub getOperators{
return ("\+", "-", "\*", "/"); # '^'' is excluded from this since it can also produce
#complex functions, and should be considered a function not an operator
}
=head1 getOperatorsRegex
Returns the valid operators as regex matcher string
@returns regex <String> :
=cut
sub getOperatorsRegex{
return "(\+|-|\*|/|\^)"; # $ is included here since we want to match valid operators,
# and it is difficult to integrate it with standardFuncsRegex subroutine.
}
=head1 getStandardFuncs
Gets all standard mathematical functions that are used in integrals
@param n int: nesting factor placeholder, starting at 1
(For later use when generating random formulas)
@returns <Array> : contains all the symbolic elementary functions with placeholder '__vars$n__'
=cut
sub getStandardFuncs{
my $n = shift();
if(!defined($n) || $n <= 0){
$n = 1;
}
my $p = "\_\_VAR$n\_\_";
# (polynomials/exponentials, roots, sin, cos, tan, log,
# arccos, arcsin, arctan,
# sec, csc, cot
# arcsec, arccsc, arccot
# sinh, cosh, tanh,
# sech, cosh, tanh,
# arcsinh, arccosh, arctanh,
# arcsech, arccsch, arccoth)
my @funcs = ("$p\^\($p\)", "$p\^\(1\/$p\)", "sin\($p\)", "cos\($p\)", "tan\($p\)", "log\($p\)",
"arcsin\($p\)", "arccos\($p\)", "arctan\($p\)",
"sec\($p\)", "csc\($p\)", "cot\($p\)",
"arcsec\($p\)", "arccsc\($p\)", "arccot\($p\)",
"sinh\($p\)", "cosh\($p\)", "tanh\($p\)",
"sech\($p\)", "csch\($p\)", "coth\($p\)",
"arcsinh\($p\)", "arccosh\($p\)", "arctanh\($p\)",
"arcsech\($p\)", "arccsch\($p\)", "arccoth\($p\)");
}
=head1 getStandardFuncsRegex
Used for matching valid 'string' symbolic functions so it excludes ^ exponentionation operator.
This operator is included in getOperatorsRegex
@returns regexMatching <string> : matches 'string' symbolic functions used in Aitegral
=cut
sub getStandardFuncsRegex{
return "(sin|cos|tan|log|arcsin|arccos|arctan|sec|csc|cot|arcsec|arccsc|arccot|sinh|cosh|tanh|arcsinh|arccosh|arctanh|arcsech|arccsch|arccoth)";
}
1;
=head1 Author(s)
Alexandre Lamarre
=cut | 29.807453 | 148 | 0.621588 |
ed2b2142b2ea1a0f3eded003b417fa677907b3b5 | 518 | t | Perl | t/pod.t | innovativeinnovation/epfl-sciper-list | 37eb45a779d7f5ef16f2cf97d809a50d60fae621 | [
"Apache-2.0"
] | null | null | null | t/pod.t | innovativeinnovation/epfl-sciper-list | 37eb45a779d7f5ef16f2cf97d809a50d60fae621 | [
"Apache-2.0"
] | 6 | 2018-10-16T23:11:38.000Z | 2019-08-23T18:52:44.000Z | t/pod.t | innovativeinnovation/epfl-sciper-list | 37eb45a779d7f5ef16f2cf97d809a50d60fae621 | [
"Apache-2.0"
] | null | null | null | # Original work (c) ECOLE POLYTECHNIQUE FEDERALE DE LAUSANNE, Switzerland, VPSI, 2017-2018.
# Modified work (c) William Belle, 2018-2019.
# See the LICENSE file for more details.
use 5.006;
use strict;
use warnings;
use Test::More;
unless ( $ENV{RELEASE_TESTING} ) {
plan( skip_all => 'Author tests not required for installation' );
}
# Ensure a recent version of Test::Pod
my $min_tp = 1.22;
eval "use Test::Pod $min_tp";
plan skip_all => "Test::Pod $min_tp required for testing POD" if $@;
all_pod_files_ok();
| 25.9 | 91 | 0.716216 |
ed6fabbfca1a5a1d1c53294aacc528cf63dd53b3 | 876 | pl | Perl | src/perl/runCA_wrapper.pl | IGS/ergatis | 36e72dc0ccbdbd59978af6f3be83fd329acc4605 | [
"Artistic-1.0"
] | 10 | 2015-08-11T02:59:23.000Z | 2021-05-15T22:58:34.000Z | src/perl/runCA_wrapper.pl | IGS/ergatis | 36e72dc0ccbdbd59978af6f3be83fd329acc4605 | [
"Artistic-1.0"
] | null | null | null | src/perl/runCA_wrapper.pl | IGS/ergatis | 36e72dc0ccbdbd59978af6f3be83fd329acc4605 | [
"Artistic-1.0"
] | 12 | 2015-07-29T14:09:09.000Z | 2021-08-28T16:20:09.000Z | #!/usr/bin/env perl
## Will run the runCA executable with the passed in options.
## This will take in a list of files and call runCA using all
## of the files as input
use strict;
use warnings;
use Getopt::Long;
my %options;
my $results = GetOptions (\%options,
'input_list|i=s',
'runca_opts|r=s',
'runca_bin|b=s' );
foreach my $req ( qw(input_list runca_opts runca_bin) ) {
die("Option $req is required") unless( $options{$req} );
}
open(IN, "< $options{'input_list'}") or die("Couldn't open $options{'input_list'} $!");
chomp( my @files = <IN> );
close(IN);
my $input_string = join(" ", @files);
my $cmd = $options{'runca_bin'};
$cmd .= " ".$options{'runca_opts'};
$cmd .= " ".$input_string;
open( OUT, "$cmd |") or die("Could not open $cmd");
map { print $_; } <OUT>;
close(OUT);
| 25.028571 | 87 | 0.585616 |
ed9f55bb005e544cb6f6d63eaecadbef8f4e755c | 2,636 | pm | Perl | network/mrv/optiswitch/snmp/mode/components/psu.pm | petneli/centreon-plugins | d131e60a1859fdd0e959623de56e6e7512c669af | [
"Apache-2.0"
] | 316 | 2015-01-18T20:37:21.000Z | 2022-03-27T00:20:35.000Z | network/mrv/optiswitch/snmp/mode/components/psu.pm | petneli/centreon-plugins | d131e60a1859fdd0e959623de56e6e7512c669af | [
"Apache-2.0"
] | 2,333 | 2015-04-26T19:10:19.000Z | 2022-03-31T15:35:21.000Z | network/mrv/optiswitch/snmp/mode/components/psu.pm | petneli/centreon-plugins | d131e60a1859fdd0e959623de56e6e7512c669af | [
"Apache-2.0"
] | 371 | 2015-01-18T20:37:23.000Z | 2022-03-22T10:10:16.000Z | #
# Copyright 2021 Centreon (http://www.centreon.com/)
#
# Centreon is a full-fledged industry-strength solution that meets
# the needs in IT infrastructure and application monitoring for
# service performance.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
package network::mrv::optiswitch::snmp::mode::components::psu;
use strict;
use warnings;
my %map_psu_status = (
1 => 'none',
2 => 'active',
3 => 'notActive',
);
my $mapping = {
nbsDevPSOperStatus => { oid => '.1.3.6.1.4.1.629.1.50.11.1.8.2.1.5', map => \%map_psu_status },
};
sub load {
my ($self) = @_;
push @{$self->{request}}, { oid => $mapping->{nbsDevPSOperStatus}->{oid} };
}
sub check {
my ($self) = @_;
$self->{output}->output_add(long_msg => "Checking power supply");
$self->{components}->{psu} = {name => 'psu', total => 0, skip => 0};
return if ($self->check_filter(section => 'psu'));
foreach my $oid ($self->{snmp}->oid_lex_sort(keys %{$self->{results}->{$mapping->{nbsDevPSOperStatus}->{oid}}})) {
next if ($oid !~ /^$mapping->{nbsDevPSOperStatus}->{oid}\.(.*)$/);
my $instance = $1;
my $result = $self->{snmp}->map_instance(mapping => $mapping, results => $self->{results}->{$mapping->{nbsDevPSOperStatus}->{oid}}, instance => $instance);
next if ($self->check_filter(section => 'psu', instance => $instance));
$self->{components}->{psu}->{total}++;
$self->{output}->output_add(long_msg => sprintf("power supply '%s' state is %s [instance: %s].",
$instance, $result->{nbsDevPSOperStatus}, $instance
));
my $exit = $self->get_severity(section => 'psu', value => $result->{nbsDevPSOperStatus});
if (!$self->{output}->is_status(value => $exit, compare => 'ok', litteral => 1)) {
$self->{output}->output_add(severity => $exit,
short_msg => sprintf("power supply '%s' state is %s",
$instance, $result->{nbsDevPSOperStatus}));
}
}
}
1;
| 37.657143 | 163 | 0.589909 |
ed06552a86551f96277380b0a58f20f7d9519b20 | 1,609 | pl | Perl | utils/find_class_typos.pl | catb0t/sidef | a9ee0715bcd25bc2bb942ab0e4a386a806fa4eba | [
"Artistic-2.0"
] | 101 | 2015-01-27T17:31:01.000Z | 2022-03-27T10:14:44.000Z | utils/find_class_typos.pl | catb0t/sidef | a9ee0715bcd25bc2bb942ab0e4a386a806fa4eba | [
"Artistic-2.0"
] | 105 | 2015-03-07T11:31:53.000Z | 2021-01-18T22:29:02.000Z | utils/find_class_typos.pl | catb0t/sidef | a9ee0715bcd25bc2bb942ab0e4a386a806fa4eba | [
"Artistic-2.0"
] | 3 | 2018-04-06T17:40:07.000Z | 2020-12-09T14:42:11.000Z | #!/usr/bin/perl
# Daniel "Trizen" Șuteu
# License: GPLv3
# Date: 24 June 2017
# http://github.com/trizen
use 5.014;
use strict;
use autodie;
use warnings;
use File::Find qw(find);
use File::Basename qw(basename);
use Text::Levenshtein::XS qw(distance);
my $dir = shift() // die "usage: $0 [lib dir]\n";
if (basename($dir) ne 'lib') {
die "error: '$dir' is not a lib directory!";
}
my $typo_dist = 1; # maximum typo distance
my %invokants;
my %declarations;
find {
no_chdir => 1,
wanted => sub {
/\.pm\z/ || return;
my $content = do {
local $/;
open my $fh, '<:utf8', $_;
<$fh>;
};
if ($content =~ /\bpackage\h+(Sidef(::\w+)*)/) {
undef $declarations{$1};
}
else {
warn "Unable to extract the package name from: $_\n";
}
while ($content =~ /\b(Sidef(::\w+)+)/g) {
push @{$invokants{$1}}, $_;
}
},
} => $dir;
my @invokants = keys(%invokants);
my @declarations = keys(%declarations);
foreach my $invo (@invokants) {
next if exists($declarations{$invo});
foreach my $decl (@declarations) {
if (abs(length($invo) - length($decl)) <= $typo_dist
and distance($invo, $decl) <= $typo_dist) {
say "Possible typo: <<$invo>> instead of <<$decl>> in:";
say "\t", join(
"\n\t",
do {
my %seen;
grep { !$seen{$_}++ } @{$invokants{$invo}};
}
),
"\n";
}
}
}
| 21.171053 | 68 | 0.472965 |
ed56403c16c8260901080d6b0d669428cc8a8e77 | 2,809 | pm | Perl | auto-lib/Paws/Kinesis/GetShardIterator.pm | cah-rfelsburg/paws | de9ffb8d49627635a2da588066df26f852af37e4 | [
"Apache-2.0"
] | 2 | 2016-09-22T09:18:33.000Z | 2017-06-20T01:36:58.000Z | auto-lib/Paws/Kinesis/GetShardIterator.pm | cah-rfelsburg/paws | de9ffb8d49627635a2da588066df26f852af37e4 | [
"Apache-2.0"
] | null | null | null | auto-lib/Paws/Kinesis/GetShardIterator.pm | cah-rfelsburg/paws | de9ffb8d49627635a2da588066df26f852af37e4 | [
"Apache-2.0"
] | null | null | null |
package Paws::Kinesis::GetShardIterator;
use Moose;
has ShardId => (is => 'ro', isa => 'Str', required => 1);
has ShardIteratorType => (is => 'ro', isa => 'Str', required => 1);
has StartingSequenceNumber => (is => 'ro', isa => 'Str');
has StreamName => (is => 'ro', isa => 'Str', required => 1);
use MooseX::ClassAttribute;
class_has _api_call => (isa => 'Str', is => 'ro', default => 'GetShardIterator');
class_has _returns => (isa => 'Str', is => 'ro', default => 'Paws::Kinesis::GetShardIteratorOutput');
class_has _result_key => (isa => 'Str', is => 'ro');
1;
### main pod documentation begin ###
=head1 NAME
Paws::Kinesis::GetShardIterator - Arguments for method GetShardIterator on Paws::Kinesis
=head1 DESCRIPTION
This class represents the parameters used for calling the method GetShardIterator on the
Amazon Kinesis service. Use the attributes of this class
as arguments to method GetShardIterator.
You shouldn't make instances of this class. Each attribute should be used as a named argument in the call to GetShardIterator.
As an example:
$service_obj->GetShardIterator(Att1 => $value1, Att2 => $value2, ...);
Values for attributes that are native types (Int, String, Float, etc) can passed as-is (scalar values). Values for complex Types (objects) can be passed as a HashRef. The keys and values of the hashref will be used to instance the underlying object.
=head1 ATTRIBUTES
=head2 B<REQUIRED> ShardId => Str
The shard ID of the shard to get the iterator for.
=head2 B<REQUIRED> ShardIteratorType => Str
Determines how the shard iterator is used to start reading data records
from the shard.
The following are the valid shard iterator types:
=over
=item * AT_SEQUENCE_NUMBER - Start reading exactly from the position
denoted by a specific sequence number.
=item * AFTER_SEQUENCE_NUMBER - Start reading right after the position
denoted by a specific sequence number.
=item * TRIM_HORIZON - Start reading at the last untrimmed record in
the shard in the system, which is the oldest data record in the shard.
=item * LATEST - Start reading just after the most recent record in the
shard, so that you always read the most recent data in the shard.
=back
Valid values are: C<"AT_SEQUENCE_NUMBER">, C<"AFTER_SEQUENCE_NUMBER">, C<"TRIM_HORIZON">, C<"LATEST">
=head2 StartingSequenceNumber => Str
The sequence number of the data record in the shard from which to start
reading from.
=head2 B<REQUIRED> StreamName => Str
The name of the stream.
=head1 SEE ALSO
This class forms part of L<Paws>, documenting arguments for method GetShardIterator in L<Paws::Kinesis>
=head1 BUGS and CONTRIBUTIONS
The source code is located here: https://github.com/pplu/aws-sdk-perl
Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
=cut
| 28.958763 | 249 | 0.734069 |
ed7613a4da2f3f7dc7b782d0da7093c10562cde4 | 1,687 | pm | Perl | auto-lib/Paws/SSM/DeleteMaintenanceWindow.pm | agimenez/aws-sdk-perl | 9c4dff7d1af2ff0210c28ca44fb9e92bc625712b | [
"Apache-2.0"
] | null | null | null | auto-lib/Paws/SSM/DeleteMaintenanceWindow.pm | agimenez/aws-sdk-perl | 9c4dff7d1af2ff0210c28ca44fb9e92bc625712b | [
"Apache-2.0"
] | null | null | null | auto-lib/Paws/SSM/DeleteMaintenanceWindow.pm | agimenez/aws-sdk-perl | 9c4dff7d1af2ff0210c28ca44fb9e92bc625712b | [
"Apache-2.0"
] | null | null | null |
package Paws::SSM::DeleteMaintenanceWindow;
use Moose;
has WindowId => (is => 'ro', isa => 'Str', required => 1);
use MooseX::ClassAttribute;
class_has _api_call => (isa => 'Str', is => 'ro', default => 'DeleteMaintenanceWindow');
class_has _returns => (isa => 'Str', is => 'ro', default => 'Paws::SSM::DeleteMaintenanceWindowResult');
class_has _result_key => (isa => 'Str', is => 'ro');
1;
### main pod documentation begin ###
=head1 NAME
Paws::SSM::DeleteMaintenanceWindow - Arguments for method DeleteMaintenanceWindow on Paws::SSM
=head1 DESCRIPTION
This class represents the parameters used for calling the method DeleteMaintenanceWindow on the
Amazon Simple Systems Manager (SSM) service. Use the attributes of this class
as arguments to method DeleteMaintenanceWindow.
You shouldn't make instances of this class. Each attribute should be used as a named argument in the call to DeleteMaintenanceWindow.
As an example:
$service_obj->DeleteMaintenanceWindow(Att1 => $value1, Att2 => $value2, ...);
Values for attributes that are native types (Int, String, Float, etc) can passed as-is (scalar values). Values for complex Types (objects) can be passed as a HashRef. The keys and values of the hashref will be used to instance the underlying object.
=head1 ATTRIBUTES
=head2 B<REQUIRED> WindowId => Str
The ID of the Maintenance Window to delete.
=head1 SEE ALSO
This class forms part of L<Paws>, documenting arguments for method DeleteMaintenanceWindow in L<Paws::SSM>
=head1 BUGS and CONTRIBUTIONS
The source code is located here: https://github.com/pplu/aws-sdk-perl
Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
=cut
| 30.672727 | 249 | 0.742739 |
ed9bfc6e5b88cc372005f3f6c4facaab8d37259a | 1,011 | pm | Perl | lib/MusicBrainz/Server/Entity/URL/RockInChina.pm | qls0ulp/musicbrainz-server | ebe8a45bf6f336352cd5c56e2e825d07679c0e45 | [
"BSD-2-Clause"
] | null | null | null | lib/MusicBrainz/Server/Entity/URL/RockInChina.pm | qls0ulp/musicbrainz-server | ebe8a45bf6f336352cd5c56e2e825d07679c0e45 | [
"BSD-2-Clause"
] | null | null | null | lib/MusicBrainz/Server/Entity/URL/RockInChina.pm | qls0ulp/musicbrainz-server | ebe8a45bf6f336352cd5c56e2e825d07679c0e45 | [
"BSD-2-Clause"
] | 1 | 2021-02-24T13:14:25.000Z | 2021-02-24T13:14:25.000Z | package MusicBrainz::Server::Entity::URL::RockInChina;
use Moose;
extends 'MusicBrainz::Server::Entity::URL';
with 'MusicBrainz::Server::Entity::URL::Sidebar';
sub sidebar_name {
my $self = shift;
return "Rock in China";
}
__PACKAGE__->meta->make_immutable;
no Moose;
1;
=head1 COPYRIGHT
Copyright (C) 2012 MetaBrainz Foundation
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
=cut
| 27.324324 | 68 | 0.770524 |
edca7c3abc8d3209f8ee8dd8faa87eae23dd3ed6 | 6,362 | pl | Perl | main/plugins/org.talend.developpement/script/backport-svn17.pl | dmytro-sylaiev/tcommon-studio-se | b75fadfb9bd1a42897073fe2984f1d4fb42555bd | [
"Apache-2.0"
] | 75 | 2015-01-29T03:23:32.000Z | 2022-02-26T07:05:40.000Z | main/plugins/org.talend.developpement/script/backport-svn17.pl | dmytro-sylaiev/tcommon-studio-se | b75fadfb9bd1a42897073fe2984f1d4fb42555bd | [
"Apache-2.0"
] | 813 | 2015-01-21T09:36:31.000Z | 2022-03-30T01:15:29.000Z | main/plugins/org.talend.developpement/script/backport-svn17.pl | dmytro-sylaiev/tcommon-studio-se | b75fadfb9bd1a42897073fe2984f1d4fb42555bd | [
"Apache-2.0"
] | 272 | 2015-01-08T06:47:46.000Z | 2022-02-09T23:22:27.000Z | #!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;
use Term::Prompt;
use File::Path;
# set English locale
$ENV{'LANG'} = "en_US.utf8";
$ENV{'LC_ALL'}="en_US.utf8";
my $svncommand = "/usr/bin/svn";
#check svn version
my $svnversioncommand = $svncommand." --version";
my $svnversioncommandoutput = `$svnversioncommand`;
my $svnmergeaddparams = "";
if ( $svnversioncommandoutput =~ m/version 1.4/ ) {
#nothing to do
} elsif ( $svnversioncommandoutput =~ m/version 1.[567]/ ) {
$svnmergeaddparams = "--depth infinity";
} else {
die "this script only supports 1.4 to 1.7 versions of svn ";
}
my $logfile = "/tmp/svnmergelog.".$$;
my $rootpath = "/tmp/svnmerge.".$$;
my $rooturl = "http://talendforge.org/svn";
sub usage {
print "backport 123 456 ... from x.x/trunk to x.x/trunk\n";
}
if (scalar @ARGV == 0) {
usage;
exit 0;
}
#parse arguments
my @revs;
my $from = "";
my $fromurl;
my $to = "";
my $tourl;
my $type = 0; #0 collect revs / 1 collect from / 2 collect to
for my $arg(@ARGV) {
if ($type == 0) {
if ($arg =~ m/^(\d+)$/) {
push @revs, $arg;
} elsif ($arg eq "from") {
$type = 1;
} else {
usage;
die $arg." is not a revision number";
}
} elsif ($type == 1) {
if ($arg eq "trunk") {
$from = $arg;
$fromurl = $from;
} elsif ($arg =~ m/^(\d+)\.(\d+)$/) {
$from = "branch ".$1.".".$2;
$fromurl = "branches/branch-".$1."_".$2;
} elsif ($arg =~ m/^(\d+)\.(\d+)\.(.*)$/) {
$from = "branch ".$1.".".$2.".".$3;
$fromurl = "branches/branch-".$1."_".$2."_".$3;
} elsif ($arg eq "to") {
$type = 2;
} else {
usage;
die $arg." must be x.x or x.y.z or or trunk";
}
} elsif ($type == 2) {
if ($arg eq "trunk") {
$to = $arg;
$tourl = $to;
} elsif ($arg =~ m/^(\d+)\.(\d+)$/) {
$to = "branch ".$1.".".$2;
$tourl = "branches/branch-".$1."_".$2;
} elsif ($arg =~ m/^(\d+)\.(\d+)\.(.*)$/) {
$to = "branch ".$1.".".$2.".".$3;
$tourl = "branches/branch-".$1."_".$2."_".$3;
} else {
usage;
die $arg." must be x.x or x.y.z or trunk";
}
}
}
if (scalar @revs == 0 ) {
usage;
die "you must provide at least one revision number";
}
if (length $from == 0 ) {
usage;
die "you must provide a from clause";
}
if (length $to == 0 ) {
usage;
die "you must provide a to clause";
}
if ($to eq $from) {
usage;
die "from and to must be different";
}
#do merge
for my $rev (@revs) {
#log
my $msglogcommand = $svncommand." log -r".$rev." ".$rooturl;
my $msglog = `$msglogcommand`;
my @msgloglines = split("\n", $msglog);
open(LOGFILE, ">", $logfile) || die "cannot open file $logfile";
print LOGFILE "merge r".$rev." from ".$from." to ".$to."\n";
#don't care of three first lines and last line
for(my $i = 3 ; $i < scalar @msgloglines - 1 ; $i++) {
print LOGFILE $msgloglines[$i], "\n";
}
close(LOGFILE);
#modified files
my $pathlogcommand = $svncommand." log --xml -v -r".$rev." ".$rooturl;
my @files;
my $pathlog = `$pathlogcommand`;
while($pathlog =~ m{<path[^>]+>([^<]+)</path>}g) {
push @files, $1;
}
#compute destination files
for my $file (@files) {
$file =~ s/$fromurl/$tourl/;
}
#checkout root
unless(-d $rootpath) {
my $checkoutcommand = $svncommand." checkout -N ".$rooturl." ".$rootpath;
print $checkoutcommand, "\n";
system $checkoutcommand;
}
#update non recursive on needed childs
for my $file (@files) {
my @segments = split("/", $file);
my %paths;
my $path = "";
for(my $i = 0 ; $i < scalar @segments ; $i++) {
$path = $path.$segments[$i];
unless(-e $rootpath.$path) {
my $svncheckoutcommand;
if ( $svnversioncommandoutput =~ m/version 1.7/ ) {
$svncheckoutcommand = $svncommand." up -N ".$rootpath.$path;
} else {
$svncheckoutcommand = $svncommand." up -N ".$rooturl.$path." ".$rootpath.$path;
}
print $svncheckoutcommand, "\n";
system $svncheckoutcommand;
}
$paths{path}++;
$path = $path."/";
}
}
#find relevants reps
my %reps;
for my $file (@files) {
if ($file =~ m{([^/]+)/}) {
$reps{$1}++;
}
}
#merge
print "\n--------------------------------------------------\n\n";
my @mergecommands;
for my $rep (keys %reps) {
push @mergecommands, $svncommand." merge ".$svnmergeaddparams." -c".$rev." ".$rooturl."/".$rep."/".$fromurl." ".$rootpath."/".$rep."/".$tourl;
}
for my $mergecommand (@mergecommands) {
print $mergecommand, "\n";
system $mergecommand;
}
#what to do
my $continue = 1;
while ($continue == 1) {
print "\n--------------------------------------------------\n\n";
my $result = &prompt("a", "log/commit/status/revert/merge again/diff/kompare/quit ?", "l/c/s/r/m/d/k/q", "s" );
if ($result eq "c") {
#commit
my $svncommitcommand = $svncommand." commit -F ".$logfile." ".$rootpath;
print $svncommitcommand, "\n";
system $svncommitcommand;
$continue = 0;
} elsif ($result eq "s") {
my $statuscommand = $svncommand." status ".$rootpath;
print $statuscommand, "\n";
system($statuscommand);
} elsif ($result eq "r") {
my $revertcommand = $svncommand." revert -R ".$rootpath;
print $revertcommand, "\n";
system($revertcommand);
} elsif ($result eq "m") {
for my $mergecommand (@mergecommands) {
print $mergecommand, "\n";
system $mergecommand;
}
} elsif ($result eq "q") {
exit 0;
} elsif ($result eq "l") {
print "\n--------------------------------------------------\n";
open(my $logfile_ifh, "<", $logfile) || die "cannot open file $logfile for reading";
while (<$logfile_ifh>) {
print $_;
}
close($logfile_ifh);
print "--------------------------------------------------\n\n";
} elsif ($result eq "d") {
my $diffcommand = $svncommand." diff ".$rootpath;
print $diffcommand, "\n";
system($diffcommand);
} elsif ($result eq "k") {
my $diffcommand = $svncommand." diff ".$rootpath." | kompare -";
print $diffcommand, "\n";
system($diffcommand);
}
}
print "\n--------------------------------------------------\n\n";
}
rmtree($rootpath);
| 26.289256 | 143 | 0.516504 |
ed06aff462c6701afcf572498286d532dcd88b34 | 1,028 | pm | Perl | plugins/FieldDay/field_types/SelectMenu/lib/FieldDay/FieldType/ChoiceList/SelectMenu.pm | movabletype/mt-plugin-field-day | 5ee2675ac488c2e66284e99349cf1d8e9edb751a | [
"MIT"
] | null | null | null | plugins/FieldDay/field_types/SelectMenu/lib/FieldDay/FieldType/ChoiceList/SelectMenu.pm | movabletype/mt-plugin-field-day | 5ee2675ac488c2e66284e99349cf1d8e9edb751a | [
"MIT"
] | null | null | null | plugins/FieldDay/field_types/SelectMenu/lib/FieldDay/FieldType/ChoiceList/SelectMenu.pm | movabletype/mt-plugin-field-day | 5ee2675ac488c2e66284e99349cf1d8e9edb751a | [
"MIT"
] | null | null | null | ##########################################################################
# Copyright (C) 2008-2010 Six Apart Ltd.
# This program is free software: you can redistribute it and/or modify it
# under the terms of version 2 of the GNU General Public License as published
# by the Free Software Foundation, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
# version 2 for more details. You should have received a copy of the GNU
# General Public License version 2 along with this program. If not, see
# <http://www.gnu.org/licenses/>.
package FieldDay::FieldType::ChoiceList::SelectMenu;
use strict;
use base qw( FieldDay::FieldType::ChoiceList );
sub label {
return 'Select Menu';
}
# the field type that contains the options template, used for subclasses
sub options_tmpl_type {
return 'ChoiceList';
}
1;
| 35.448276 | 77 | 0.70428 |
edc2f31343b6e86a95866654e3a43373ee790866 | 1,854 | t | Perl | t/ioasync_uncaught_failure.t | FGasper/p5-Protocol-DBus | 8330c2414480fd0e8d2d48d139a3f9b1837aae4d | [
"Artistic-1.0-cl8"
] | 11 | 2018-10-28T18:44:44.000Z | 2021-03-03T20:02:19.000Z | t/ioasync_uncaught_failure.t | FGasper/p5-Protocol-DBus | 8330c2414480fd0e8d2d48d139a3f9b1837aae4d | [
"Artistic-1.0-cl8"
] | 7 | 2018-09-30T15:08:24.000Z | 2021-04-18T12:27:56.000Z | t/ioasync_uncaught_failure.t | FGasper/p5-Protocol-DBus | 8330c2414480fd0e8d2d48d139a3f9b1837aae4d | [
"Artistic-1.0-cl8"
] | 3 | 2018-09-29T22:46:10.000Z | 2021-04-18T08:35:23.000Z | #!/usr/bin/env perl
use strict;
use warnings;
use Test::More;
use Test::FailWarnings;
use Promise::ES6;
use FindBin;
use lib "$FindBin::Bin/lib";
use DBusSession;
SKIP: {
skip 'No IO::Async!', 1 if !eval { require IO::Async::Loop };
my $loop = IO::Async::Loop->new();
skip 'Loop can’t watch_time()!', 1 if !$loop->can('watch_time');
DBusSession::skip_if_lack_needed_socket_msghdr(1);
DBusSession::get_bin_or_skip();
my $session = DBusSession->new();
require Protocol::DBus::Client::IOAsync;
my $dbus = eval {
Protocol::DBus::Client::IOAsync::login_session($loop);
} or skip "Can’t open login session: $@";
my $dbus_p = $dbus->initialize()->then(
sub {
my $msgr = shift;
# NOT to be done in production. This can change at any time.
my $dbus = $msgr->_dbus();
my $fileno = $dbus->fileno();
open my $fh, "+>&=$fileno" or die "failed to take fd $fileno: $!";
syswrite $fh, 'z';
return $msgr->send_signal(
path => '/what/ever',
interface => 'what.ever',
member => 'member',
)->then(
sub { diag "signal sent\n" },
sub { diag "signal NOT sent\n" },
);
},
sub {
skip "Failed to initialize: $_[0]", 1;
},
);
my $warn_y;
my $warn_p = Promise::ES6->new( sub {
$warn_y = shift;
} );
my @w;
do {
local $SIG{'__WARN__'} = sub {
$warn_y->();
push @w, @_;
};
Promise::ES6->all([$dbus_p, $warn_p])->then( sub {
$loop->stop();
} );
$loop->run();
};
is(
0 + @w,
1,
'single warning',
) or diag explain \@w;
};
done_testing;
1;
| 21.068182 | 78 | 0.484898 |
edb7ab066cb993814b91da8998dcef92d380f223 | 43,564 | pm | Perl | windows/cperl/lib/File/Path.pm | SCOTT-HAMILTON/Monetcours | 66a2970218a31e9987a4e7eb37443c54f22e6825 | [
"MIT"
] | null | null | null | windows/cperl/lib/File/Path.pm | SCOTT-HAMILTON/Monetcours | 66a2970218a31e9987a4e7eb37443c54f22e6825 | [
"MIT"
] | null | null | null | windows/cperl/lib/File/Path.pm | SCOTT-HAMILTON/Monetcours | 66a2970218a31e9987a4e7eb37443c54f22e6825 | [
"MIT"
] | null | null | null | package File::Path;
use 5.005_04;
use strict;
use Cwd ();
use File::Basename ();
use File::Spec ();
BEGIN {
if ( $] < 5.006 ) {
# can't say 'opendir my $dh, $dirname'
# need to initialise $dh
eval 'use Symbol';
}
if ( $^V !~ /c$/ ) {
die("requires cperl signatures with types");
#require experimental;
#import experimental 'signatures';
}
}
use Exporter ();
use vars qw($VERSION @ISA @EXPORT @EXPORT_OK);
$VERSION = '3.16_02c';
$VERSION =~ tr/_//d;
$VERSION =~ s/c$//;
$VERSION = eval $VERSION;
@ISA = qw(Exporter);
@EXPORT = qw(mkpath rmtree);
@EXPORT_OK = qw(make_path remove_tree);
BEGIN {
for (qw(VMS MacOS MSWin32 os2)) {
no strict 'refs';
*{"_IS_\U$_"} = $^O eq $_ ? sub () { 1 } : sub () { 0 };
}
# These OSes complain if you want to remove a file that you have no
# write permission to:
*_FORCE_WRITABLE = (
grep { $^O eq $_ } qw(amigaos dos epoc MSWin32 MacOS os2)
) ? sub () { 1 } : sub () { 0 };
# Unix-like systems need to stat each directory in order to detect
# race condition. MS-Windows is immune to this particular attack.
*_NEED_STAT_CHECK = !(_IS_MSWIN32()) ? sub () { 1 } : sub () { 0 };
}
sub _carp {
require Carp;
goto &Carp::carp;
}
sub _croak {
require Carp;
goto &Carp::croak;
}
sub _error ($arg, str $message, $object?) {
if ($arg->{error}) {
$object = '' unless defined $object;
$message .= ": $!" if $!;
push @{ ${ $arg->{error} } }, { $object => $message };
}
else {
_carp( defined($object) ? "$message for $object: $!" : "$message: $!" );
}
}
sub __is_arg {
my ($arg) = @_;
# If client code blessed an array ref to HASH, this will not work
# properly. We could have done $arg->isa() wrapped in eval, but
# that would be expensive. This implementation should suffice.
# We could have also used Scalar::Util:blessed, but we choose not
# to add this dependency
return ( ref $arg eq 'HASH' );
}
sub make_path {
push @_, {} unless @_ and __is_arg( $_[-1] );
goto &mkpath;
}
sub mkpath {
my $old_style = !( @_ and __is_arg( $_[-1] ) );
my $data;
my $paths;
if ($old_style) {
my ( $verbose, $mode );
( $paths, $verbose, $mode ) = @_;
$paths = [$paths] unless UNIVERSAL::isa( $paths, 'ARRAY' );
$data->{verbose} = $verbose;
$data->{mode} = defined $mode ? $mode : oct '777';
}
else {
my %args_permitted = map { $_ => 1 } ( qw|
chmod
error
group
mask
mode
owner
uid
user
verbose
| );
my %not_on_win32_args = map { $_ => 1 } ( qw|
group
owner
uid
user
| );
my @bad_args = ();
my @win32_implausible_args = ();
my $arg = pop @_;
for my $k (sort keys %{$arg}) {
if (! $args_permitted{$k}) {
push @bad_args, $k;
}
elsif ($not_on_win32_args{$k} and _IS_MSWIN32) {
push @win32_implausible_args, $k;
}
else {
$data->{$k} = $arg->{$k};
}
}
_carp("Unrecognized option(s) passed to mkpath() or make_path(): @bad_args")
if @bad_args;
_carp("Option(s) implausible on Win32 passed to mkpath() or make_path(): @win32_implausible_args")
if @win32_implausible_args;
$data->{mode} = delete $data->{mask} if exists $data->{mask};
$data->{mode} = oct '777' unless exists $data->{mode};
${ $data->{error} } = [] if exists $data->{error};
unless (@win32_implausible_args) {
$data->{owner} = delete $data->{user} if exists $data->{user};
$data->{owner} = delete $data->{uid} if exists $data->{uid};
if ( exists $data->{owner} and $data->{owner} =~ /\D/ ) {
my $uid = ( getpwnam $data->{owner} )[2];
if ( defined $uid ) {
$data->{owner} = $uid;
}
else {
_error( $data,
"unable to map $data->{owner} to a uid, ownership not changed"
);
delete $data->{owner};
}
}
if ( exists $data->{group} and $data->{group} =~ /\D/ ) {
my $gid = ( getgrnam $data->{group} )[2];
if ( defined $gid ) {
$data->{group} = $gid;
}
else {
_error( $data,
"unable to map $data->{group} to a gid, group ownership not changed"
);
delete $data->{group};
}
}
if ( exists $data->{owner} and not exists $data->{group} ) {
$data->{group} = -1; # chown will leave group unchanged
}
if ( exists $data->{group} and not exists $data->{owner} ) {
$data->{owner} = -1; # chown will leave owner unchanged
}
}
$paths = [@_];
}
return _mkpath( $data, $paths );
}
sub _mkpath ($data, $paths) {
my ( @created );
foreach my $path ( @{$paths} ) {
next unless defined($path) and length($path);
$path .= '/' if _IS_OS2 and $path =~ /^\w:\z/s; # feature of CRT
# Logic wants Unix paths, so go with the flow.
if (_IS_VMS) {
next if $path eq '/';
$path = VMS::Filespec::unixify($path);
}
next if -d $path;
my $parent = File::Basename::dirname($path);
# Coverage note: It's not clear how we would test the condition:
# '-d $parent or $path eq $parent'
unless ( -d $parent or $path eq $parent ) {
push( @created, _mkpath( $data, [$parent] ) );
}
print "mkdir $path\n" if $data->{verbose};
if ( mkdir( $path, $data->{mode} ) ) {
push( @created, $path );
if ( exists $data->{owner} ) {
# NB: $data->{group} guaranteed to be set during initialisation
if ( !chown $data->{owner}, $data->{group}, $path ) {
_error( $data,
"Cannot change ownership of $path to $data->{owner}:$data->{group}"
);
}
}
if ( exists $data->{chmod} ) {
# Coverage note: It's not clear how we would trigger the next
# 'if' block. Failure of 'chmod' might first result in a
# system error: "Permission denied".
if ( !chmod $data->{chmod}, $path ) {
_error( $data,
"Cannot change permissions of $path to $data->{chmod}" );
}
}
}
else {
my $save_bang = $!;
# From 'perldoc perlvar': $EXTENDED_OS_ERROR ($^E) is documented
# as:
# Error information specific to the current operating system. At the
# moment, this differs from "$!" under only VMS, OS/2, and Win32
# (and for MacPerl). On all other platforms, $^E is always just the
# same as $!.
my ( $e, $e1 ) = ( $save_bang, $^E );
$e .= "; $e1" if $e ne $e1;
# allow for another process to have created it meanwhile
if ( ! -d $path ) {
$! = $save_bang;
if ( $data->{error} ) {
push @{ ${ $data->{error} } }, { $path => $e };
}
else {
_croak("mkdir $path: $e");
}
}
}
}
return @created;
}
sub remove_tree {
push @_, {} unless @_ and __is_arg( $_[-1] );
goto &rmtree;
}
sub _is_subdir (str $dir, str $test) {
my ( $dv, $dd ) = File::Spec->splitpath( $dir, 1 );
my ( $tv, $td ) = File::Spec->splitpath( $test, 1 );
# not on same volume
return 0 if $dv ne $tv;
my @d = File::Spec->splitdir($dd);
my @t = File::Spec->splitdir($td);
# @t can't be a subdir if it's shorter than @d
return 0 if @t < @d;
return join( '/', @d ) eq join( '/', splice @t, 0, +@d );
}
sub rmtree {
my $old_style = !( @_ and __is_arg( $_[-1] ) );
my ($arg, $data, $paths);
if ($old_style) {
my ( $verbose, $safe );
( $paths, $verbose, $safe ) = @_;
$data->{verbose} = $verbose;
$data->{safe} = defined $safe ? $safe : 0;
if ( defined($paths) and length($paths) ) {
$paths = [$paths] unless UNIVERSAL::isa( $paths, 'ARRAY' );
}
else {
_carp("No root path(s) specified\n");
return 0;
}
}
else {
my %args_permitted = map { $_ => 1 } ( qw|
error
keep_root
result
safe
verbose
| );
my @bad_args = ();
my $arg = pop @_;
for my $k (sort keys %{$arg}) {
if (! $args_permitted{$k}) {
push @bad_args, $k;
}
else {
$data->{$k} = $arg->{$k};
}
}
_carp("Unrecognized option(s) passed to remove_tree(): @bad_args")
if @bad_args;
${ $data->{error} } = [] if exists $data->{error};
${ $data->{result} } = [] if exists $data->{result};
# Wouldn't it make sense to do some validation on @_ before assigning
# to $paths here?
# In the $old_style case we guarantee that each path is both defined
# and non-empty. We don't check that here, which means we have to
# check it later in the first condition in this line:
# if ( $ortho_root_length && _is_subdir( $ortho_root, $ortho_cwd ) ) {
# Granted, that would be a change in behavior for the two
# non-old-style interfaces.
$paths = [@_];
}
$data->{prefix} = '';
$data->{depth} = 0;
my @clean_path;
$data->{cwd} = Cwd::abs_path(Cwd::getcwd()) or do {
_error( $data, "cannot fetch initial working directory" );
return 0;
};
for ( $data->{cwd} ) { /\A(.*)\Z/s; $_ = $1 } # untaint
for my $p (@$paths) {
# need to fixup case and map \ to / on Windows
my $ortho_root = _IS_MSWIN32 ? _slash_lc($p) : $p;
my $ortho_cwd =
_IS_MSWIN32 ? _slash_lc( $data->{cwd} ) : $data->{cwd};
my $ortho_root_length = length($ortho_root);
$ortho_root_length-- if _IS_VMS; # don't compare '.' with ']'
if ( $ortho_root_length && _is_subdir( $ortho_root, $ortho_cwd ) ) {
local $! = 0;
_error( $data, "cannot remove path when cwd is $data->{cwd}", $p );
next;
}
if (_IS_MACOS) {
$p = ":$p" unless $p =~ /:/;
$p .= ":" unless $p =~ /:\z/;
}
elsif ( _IS_MSWIN32 ) {
$p =~ s{[/\\]\z}{};
}
else {
$p =~ s{/\z}{};
}
push @clean_path, $p;
}
@{$data}{qw(device inode)} = ( lstat $data->{cwd} )[ 0, 1 ] or do {
_error( $data, "cannot stat initial working directory", $data->{cwd} );
return 0;
};
return _rmtree( $data, \@clean_path );
}
sub _rmtree ($data, $paths) {
my $count = 0;
my $curdir = File::Spec->curdir();
my $updir = File::Spec->updir();
my ( @files, $root );
ROOT_DIR:
foreach my $root (@$paths) {
# since we chdir into each directory, it may not be obvious
# to figure out where we are if we generate a message about
# a file name. We therefore construct a semi-canonical
# filename, anchored from the directory being unlinked (as
# opposed to being truly canonical, anchored from the root (/).
my $canon =
$data->{prefix}
? File::Spec->catfile( $data->{prefix}, $root )
: $root;
my ( $ldev, $lino, $perm ) = ( lstat $root )[ 0, 1, 2 ]
or next ROOT_DIR;
if ( -d _ ) {
$root = VMS::Filespec::vmspath( VMS::Filespec::pathify($root) )
if _IS_VMS;
if ( !chdir($root) ) {
# see if we can escalate privileges to get in
# (e.g. funny protection mask such as -w- instead of rwx)
# This uses fchmod to avoid traversing outside of the proper
# location (CVE-2017-6512)
my $root_fh;
if (open($root_fh, '<', $root)) {
my ($fh_dev, $fh_inode) = (stat $root_fh )[0,1];
$perm &= oct '7777';
my $nperm = $perm | oct '700';
local $@;
if (
!(
$data->{safe}
or $nperm == $perm
or !-d _
or $fh_dev ne $ldev
or $fh_inode ne $lino
or eval { chmod( $nperm, $root_fh ) }
)
)
{
_error( $data,
"cannot make child directory read-write-exec", $canon );
next ROOT_DIR;
}
close $root_fh;
}
if ( !chdir($root) ) {
_error( $data, "cannot chdir to child", $canon );
next ROOT_DIR;
}
}
my ( $cur_dev, $cur_inode, $perm ) = ( stat $curdir )[ 0, 1, 2 ]
or do {
_error( $data, "cannot stat current working directory", $canon );
next ROOT_DIR;
};
if (_NEED_STAT_CHECK) {
( $ldev eq $cur_dev and $lino eq $cur_inode )
or _croak(
"directory $canon changed before chdir, expected dev=$ldev ino=$lino, actual dev=$cur_dev ino=$cur_inode, aborting"
);
}
$perm &= oct '7777'; # don't forget setuid, setgid, sticky bits
my $nperm = $perm | oct '700';
# notabene: 0700 is for making readable in the first place,
# it's also intended to change it to writable in case we have
# to recurse in which case we are better than rm -rf for
# subtrees with strange permissions
if (
!(
$data->{safe}
or $nperm == $perm
or chmod( $nperm, $curdir )
)
)
{
_error( $data, "cannot make directory read+writeable", $canon );
$nperm = $perm;
}
my $d;
$d = gensym() if $] < 5.006;
if ( !opendir $d, $curdir ) {
_error( $data, "cannot opendir", $canon );
@files = ();
}
else {
if ( !defined ${^TAINT} or ${^TAINT} ) {
# Blindly untaint dir names if taint mode is active
@files = map { /\A(.*)\z/s; $1 } readdir $d;
}
else {
@files = readdir $d;
}
closedir $d;
}
if (_IS_VMS) {
# Deleting large numbers of files from VMS Files-11
# filesystems is faster if done in reverse ASCIIbetical order.
# include '.' to '.;' from blead patch #31775
@files = map { $_ eq '.' ? '.;' : $_ } reverse @files;
}
@files = grep { $_ ne $updir and $_ ne $curdir } @files;
if (@files) {
# remove the contained files before the directory itself
my $narg = {%$data};
@{$narg}{qw(device inode cwd prefix depth)} =
( $cur_dev, $cur_inode, $updir, $canon, $data->{depth} + 1 );
$count += _rmtree( $narg, \@files );
}
# restore directory permissions of required now (in case the rmdir
# below fails), while we are still in the directory and may do so
# without a race via '.'
if ( $nperm != $perm and not chmod( $perm, $curdir ) ) {
_error( $data, "cannot reset chmod", $canon );
}
# don't leave the client code in an unexpected directory
chdir( $data->{cwd} )
or
_croak("cannot chdir to $data->{cwd} from $canon: $!, aborting");
# ensure that a chdir upwards didn't take us somewhere other
# than we expected (see CVE-2002-0435)
( $cur_dev, $cur_inode ) = ( stat $curdir )[ 0, 1 ]
or _croak(
"cannot stat prior working directory $data->{cwd}: $!, aborting"
);
if (_NEED_STAT_CHECK) {
# when the cwd symlink crosses a mountpoint this would fail
( -l $data->{cwd} or
( $data->{device} eq $cur_dev and $data->{inode} eq $cur_inode ))
or _croak( "previous directory $data->{cwd} "
. "changed before entering $canon, "
. "expected dev=$ldev ino=$lino, "
. "actual dev=$cur_dev ino=$cur_inode, aborting"
);
}
if ( $data->{depth} or !$data->{keep_root} ) {
if ( $data->{safe}
&& ( _IS_VMS
? !&VMS::Filespec::candelete($root)
: !-w $root ) )
{
print "skipped $root\n" if $data->{verbose};
next ROOT_DIR;
}
if ( _FORCE_WRITABLE and !chmod $perm | oct '700', $root ) {
_error( $data, "cannot make directory writeable", $canon );
}
print "rmdir $root\n" if $data->{verbose};
if ( rmdir $root ) {
push @{ ${ $data->{result} } }, $root if $data->{result};
++$count;
}
else {
_error( $data, "cannot remove directory", $canon );
if (
_FORCE_WRITABLE
&& !chmod( $perm,
( _IS_VMS ? VMS::Filespec::fileify($root) : $root )
)
)
{
_error(
$data,
sprintf( "cannot restore permissions to 0%o",
$perm ),
$canon
);
}
}
}
}
else {
# not a directory
$root = VMS::Filespec::vmsify("./$root")
if _IS_VMS
&& !File::Spec->file_name_is_absolute($root)
&& ( $root !~ m/(?<!\^)[\]>]+/ ); # not already in VMS syntax
if (
$data->{safe}
&& (
_IS_VMS
? !&VMS::Filespec::candelete($root)
: !( -l $root || -w $root )
)
)
{
print "skipped $root\n" if $data->{verbose};
next ROOT_DIR;
}
my $nperm = $perm & oct '7777' | oct '600';
if ( _FORCE_WRITABLE
and $nperm != $perm
and not chmod $nperm, $root )
{
_error( $data, "cannot make file writeable", $canon );
}
print "unlink $canon\n" if $data->{verbose};
# delete all versions under VMS
for ( ; ; ) {
if ( unlink $root ) {
push @{ ${ $data->{result} } }, $root if $data->{result};
}
else {
_error( $data, "cannot unlink file", $canon );
_FORCE_WRITABLE and chmod( $perm, $root )
or _error( $data,
sprintf( "cannot restore permissions to 0%o", $perm ),
$canon );
last;
}
++$count;
last unless _IS_VMS && lstat $root;
}
}
}
return $count;
}
sub _slash_lc (str $path) {
# fix up slashes and case on MSWin32 so that we can determine that
# c:\path\to\dir is underneath C:/Path/To
$path =~ tr{\\}{/};
return lc($path);
}
1;
__END__
=head1 NAME
File::Path - Create or remove directory trees
=head1 VERSION
2.16 - released August 31 2018.
=head1 SYNOPSIS
use File::Path qw(make_path remove_tree);
@created = make_path('foo/bar/baz', '/zug/zwang');
@created = make_path('foo/bar/baz', '/zug/zwang', {
verbose => 1,
mode => 0711,
});
make_path('foo/bar/baz', '/zug/zwang', {
chmod => 0777,
});
$removed_count = remove_tree('foo/bar/baz', '/zug/zwang', {
verbose => 1,
error => \my $err_list,
safe => 1,
});
# legacy (interface promoted before v2.00)
@created = mkpath('/foo/bar/baz');
@created = mkpath('/foo/bar/baz', 1, 0711);
@created = mkpath(['/foo/bar/baz', 'blurfl/quux'], 1, 0711);
$removed_count = rmtree('foo/bar/baz', 1, 1);
$removed_count = rmtree(['foo/bar/baz', 'blurfl/quux'], 1, 1);
# legacy (interface promoted before v2.06)
@created = mkpath('foo/bar/baz', '/zug/zwang', { verbose => 1, mode => 0711 });
$removed_count = rmtree('foo/bar/baz', '/zug/zwang', { verbose => 1, mode => 0711 });
=head1 DESCRIPTION
This module provides a convenient way to create directories of
arbitrary depth and to delete an entire directory subtree from the
filesystem.
The following functions are provided:
=over
=item make_path( $dir1, $dir2, .... )
=item make_path( $dir1, $dir2, ...., \%opts )
The C<make_path> function creates the given directories if they don't
exist before, much like the Unix command C<mkdir -p>.
The function accepts a list of directories to be created. Its
behaviour may be tuned by an optional hashref appearing as the last
parameter on the call.
The function returns the list of directories actually created during
the call; in scalar context the number of directories created.
The following keys are recognised in the option hash:
=over
=item mode => $num
The numeric permissions mode to apply to each created directory
(defaults to C<0777>), to be modified by the current C<umask>. If the
directory already exists (and thus does not need to be created),
the permissions will not be modified.
C<mask> is recognised as an alias for this parameter.
=item chmod => $num
Takes a numeric mode to apply to each created directory (not
modified by the current C<umask>). If the directory already exists
(and thus does not need to be created), the permissions will
not be modified.
=item verbose => $bool
If present, will cause C<make_path> to print the name of each directory
as it is created. By default nothing is printed.
=item error => \$err
If present, it should be a reference to a scalar.
This scalar will be made to reference an array, which will
be used to store any errors that are encountered. See the L</"ERROR
HANDLING"> section for more information.
If this parameter is not used, certain error conditions may raise
a fatal error that will cause the program to halt, unless trapped
in an C<eval> block.
=item owner => $owner
=item user => $owner
=item uid => $owner
If present, will cause any created directory to be owned by C<$owner>.
If the value is numeric, it will be interpreted as a uid; otherwise a
username is assumed. An error will be issued if the username cannot be
mapped to a uid, the uid does not exist or the process lacks the
privileges to change ownership.
Ownership of directories that already exist will not be changed.
C<user> and C<uid> are aliases of C<owner>.
=item group => $group
If present, will cause any created directory to be owned by the group
C<$group>. If the value is numeric, it will be interpreted as a gid;
otherwise a group name is assumed. An error will be issued if the
group name cannot be mapped to a gid, the gid does not exist or the
process lacks the privileges to change group ownership.
Group ownership of directories that already exist will not be changed.
make_path '/var/tmp/webcache', {owner=>'nobody', group=>'nogroup'};
=back
=item mkpath( $dir )
=item mkpath( $dir, $verbose, $mode )
=item mkpath( [$dir1, $dir2,...], $verbose, $mode )
=item mkpath( $dir1, $dir2,..., \%opt )
The C<mkpath()> function provide the legacy interface of
C<make_path()> with a different interpretation of the arguments
passed. The behaviour and return value of the function is otherwise
identical to C<make_path()>.
=item remove_tree( $dir1, $dir2, .... )
=item remove_tree( $dir1, $dir2, ...., \%opts )
The C<remove_tree> function deletes the given directories and any
files and subdirectories they might contain, much like the Unix
command C<rm -rf> or the Windows commands C<rmdir /s> and C<rd /s>.
The function accepts a list of directories to be removed. (In point of fact,
it will also accept filesystem entries which are not directories, such as
regular files and symlinks. But, as its name suggests, its intent is to
remove trees rather than individual files.)
C<remove_tree()>'s behaviour may be tuned by an optional hashref
appearing as the last parameter on the call. If an empty string is
passed to C<remove_tree>, an error will occur.
B<NOTE:> For security reasons, we strongly advise use of the
hashref-as-final-argument syntax -- specifically, with a setting of the C<safe>
element to a true value.
remove_tree( $dir1, $dir2, ....,
{
safe => 1,
... # other key-value pairs
},
);
The function returns the number of files successfully deleted.
The following keys are recognised in the option hash:
=over
=item verbose => $bool
If present, will cause C<remove_tree> to print the name of each file as
it is unlinked. By default nothing is printed.
=item safe => $bool
When set to a true value, will cause C<remove_tree> to skip the files
for which the process lacks the required privileges needed to delete
files, such as delete privileges on VMS. In other words, the code
will make no attempt to alter file permissions. Thus, if the process
is interrupted, no filesystem object will be left in a more
permissive mode.
=item keep_root => $bool
When set to a true value, will cause all files and subdirectories
to be removed, except the initially specified directories. This comes
in handy when cleaning out an application's scratch directory.
remove_tree( '/tmp', {keep_root => 1} );
=item result => \$res
If present, it should be a reference to a scalar.
This scalar will be made to reference an array, which will
be used to store all files and directories unlinked
during the call. If nothing is unlinked, the array will be empty.
remove_tree( '/tmp', {result => \my $list} );
print "unlinked $_\n" for @$list;
This is a useful alternative to the C<verbose> key.
=item error => \$err
If present, it should be a reference to a scalar.
This scalar will be made to reference an array, which will
be used to store any errors that are encountered. See the L</"ERROR
HANDLING"> section for more information.
Removing things is a much more dangerous proposition than
creating things. As such, there are certain conditions that
C<remove_tree> may encounter that are so dangerous that the only
sane action left is to kill the program.
Use C<error> to trap all that is reasonable (problems with
permissions and the like), and let it die if things get out
of hand. This is the safest course of action.
=back
=item rmtree( $dir )
=item rmtree( $dir, $verbose, $safe )
=item rmtree( [$dir1, $dir2,...], $verbose, $safe )
=item rmtree( $dir1, $dir2,..., \%opt )
The C<rmtree()> function provide the legacy interface of
C<remove_tree()> with a different interpretation of the arguments
passed. The behaviour and return value of the function is otherwise
identical to C<remove_tree()>.
B<NOTE:> For security reasons, we strongly advise use of the
hashref-as-final-argument syntax, specifically with a setting of the C<safe>
element to a true value.
rmtree( $dir1, $dir2, ....,
{
safe => 1,
... # other key-value pairs
},
);
=back
=head2 ERROR HANDLING
=over 4
=item B<NOTE:>
The following error handling mechanism is consistent throughout all
code paths EXCEPT in cases where the ROOT node is nonexistent. In
version 2.11 the maintainers attempted to rectify this inconsistency
but too many downstream modules encountered problems. In such case,
if you require root node evaluation or error checking prior to calling
C<make_path> or C<remove_tree>, you should take additional precautions.
=back
If C<make_path> or C<remove_tree> encounters an error, a diagnostic
message will be printed to C<STDERR> via C<carp> (for non-fatal
errors) or via C<croak> (for fatal errors).
If this behaviour is not desirable, the C<error> attribute may be
used to hold a reference to a variable, which will be used to store
the diagnostics. The variable is made a reference to an array of hash
references. Each hash contain a single key/value pair where the key
is the name of the file, and the value is the error message (including
the contents of C<$!> when appropriate). If a general error is
encountered the diagnostic key will be empty.
An example usage looks like:
remove_tree( 'foo/bar', 'bar/rat', {error => \my $err} );
if ($err && @$err) {
for my $diag (@$err) {
my ($file, $message) = %$diag;
if ($file eq '') {
print "general error: $message\n";
}
else {
print "problem unlinking $file: $message\n";
}
}
}
else {
print "No error encountered\n";
}
Note that if no errors are encountered, C<$err> will reference an
empty array. This means that C<$err> will always end up TRUE; so you
need to test C<@$err> to determine if errors occurred.
=head2 NOTES
C<File::Path> blindly exports C<mkpath> and C<rmtree> into the
current namespace. These days, this is considered bad style, but
to change it now would break too much code. Nonetheless, you are
invited to specify what it is you are expecting to use:
use File::Path 'rmtree';
The routines C<make_path> and C<remove_tree> are B<not> exported
by default. You must specify which ones you want to use.
use File::Path 'remove_tree';
Note that a side-effect of the above is that C<mkpath> and C<rmtree>
are no longer exported at all. This is due to the way the C<Exporter>
module works. If you are migrating a codebase to use the new
interface, you will have to list everything explicitly. But that's
just good practice anyway.
use File::Path qw(remove_tree rmtree);
=head3 API CHANGES
The API was changed in the 2.0 branch. For a time, C<mkpath> and
C<rmtree> tried, unsuccessfully, to deal with the two different
calling mechanisms. This approach was considered a failure.
The new semantics are now only available with C<make_path> and
C<remove_tree>. The old semantics are only available through
C<mkpath> and C<rmtree>. Users are strongly encouraged to upgrade
to at least 2.08 in order to avoid surprises.
=head3 SECURITY CONSIDERATIONS
There were race conditions in the 1.x implementations of File::Path's
C<rmtree> function (although sometimes patched depending on the OS
distribution or platform). The 2.0 version contains code to avoid the
problem mentioned in CVE-2002-0435.
See the following pages for more information:
http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=286905
http://www.nntp.perl.org/group/perl.perl5.porters/2005/01/msg97623.html
http://www.debian.org/security/2005/dsa-696
Additionally, unless the C<safe> parameter is set (or the
third parameter in the traditional interface is TRUE), should a
C<remove_tree> be interrupted, files that were originally in read-only
mode may now have their permissions set to a read-write (or "delete
OK") mode.
The following CVE reports were previously filed against File-Path and are
believed to have been addressed:
=over 4
=item * L<http://cve.circl.lu/cve/CVE-2004-0452>
=item * L<http://cve.circl.lu/cve/CVE-2005-0448>
=back
In February 2017 the cPanel Security Team reported an additional vulnerability
in File-Path. The C<chmod()> logic to make directories traversable can be
abused to set the mode on an attacker-chosen file to an attacker-chosen value.
This is due to the time-of-check-to-time-of-use (TOCTTOU) race condition
(L<https://en.wikipedia.org/wiki/Time_of_check_to_time_of_use>) between the
C<stat()> that decides the inode is a directory and the C<chmod()> that tries
to make it user-rwx. CPAN versions 2.13 and later incorporate a patch
provided by John Lightsey to address this problem. This vulnerability has
been reported as CVE-2017-6512.
=head1 DIAGNOSTICS
FATAL errors will cause the program to halt (C<croak>), since the
problem is so severe that it would be dangerous to continue. (This
can always be trapped with C<eval>, but it's not a good idea. Under
the circumstances, dying is the best thing to do).
SEVERE errors may be trapped using the modern interface. If the
they are not trapped, or if the old interface is used, such an error
will cause the program will halt.
All other errors may be trapped using the modern interface, otherwise
they will be C<carp>ed about. Program execution will not be halted.
=over 4
=item mkdir [path]: [errmsg] (SEVERE)
C<make_path> was unable to create the path. Probably some sort of
permissions error at the point of departure or insufficient resources
(such as free inodes on Unix).
=item No root path(s) specified
C<make_path> was not given any paths to create. This message is only
emitted if the routine is called with the traditional interface.
The modern interface will remain silent if given nothing to do.
=item No such file or directory
On Windows, if C<make_path> gives you this warning, it may mean that
you have exceeded your filesystem's maximum path length.
=item cannot fetch initial working directory: [errmsg]
C<remove_tree> attempted to determine the initial directory by calling
C<Cwd::getcwd>, but the call failed for some reason. No attempt
will be made to delete anything.
=item cannot stat initial working directory: [errmsg]
C<remove_tree> attempted to stat the initial directory (after having
successfully obtained its name via C<getcwd>), however, the call
failed for some reason. No attempt will be made to delete anything.
=item cannot chdir to [dir]: [errmsg]
C<remove_tree> attempted to set the working directory in order to
begin deleting the objects therein, but was unsuccessful. This is
usually a permissions issue. The routine will continue to delete
other things, but this directory will be left intact.
=item directory [dir] changed before chdir, expected dev=[n] ino=[n], actual dev=[n] ino=[n], aborting (FATAL)
C<remove_tree> recorded the device and inode of a directory, and then
moved into it. It then performed a C<stat> on the current directory
and detected that the device and inode were no longer the same. As
this is at the heart of the race condition problem, the program
will die at this point.
=item cannot make directory [dir] read+writeable: [errmsg]
C<remove_tree> attempted to change the permissions on the current directory
to ensure that subsequent unlinkings would not run into problems,
but was unable to do so. The permissions remain as they were, and
the program will carry on, doing the best it can.
=item cannot read [dir]: [errmsg]
C<remove_tree> tried to read the contents of the directory in order
to acquire the names of the directory entries to be unlinked, but
was unsuccessful. This is usually a permissions issue. The
program will continue, but the files in this directory will remain
after the call.
=item cannot reset chmod [dir]: [errmsg]
C<remove_tree>, after having deleted everything in a directory, attempted
to restore its permissions to the original state but failed. The
directory may wind up being left behind.
=item cannot remove [dir] when cwd is [dir]
The current working directory of the program is F</some/path/to/here>
and you are attempting to remove an ancestor, such as F</some/path>.
The directory tree is left untouched.
The solution is to C<chdir> out of the child directory to a place
outside the directory tree to be removed.
=item cannot chdir to [parent-dir] from [child-dir]: [errmsg], aborting (FATAL)
C<remove_tree>, after having deleted everything and restored the permissions
of a directory, was unable to chdir back to the parent. The program
halts to avoid a race condition from occurring.
=item cannot stat prior working directory [dir]: [errmsg], aborting (FATAL)
C<remove_tree> was unable to stat the parent directory after having returned
from the child. Since there is no way of knowing if we returned to
where we think we should be (by comparing device and inode) the only
way out is to C<croak>.
=item previous directory [parent-dir] changed before entering [child-dir], expected dev=[n] ino=[n], actual dev=[n] ino=[n], aborting (FATAL)
When C<remove_tree> returned from deleting files in a child directory, a
check revealed that the parent directory it returned to wasn't the one
it started out from. This is considered a sign of malicious activity.
=item cannot make directory [dir] writeable: [errmsg]
Just before removing a directory (after having successfully removed
everything it contained), C<remove_tree> attempted to set the permissions
on the directory to ensure it could be removed and failed. Program
execution continues, but the directory may possibly not be deleted.
=item cannot remove directory [dir]: [errmsg]
C<remove_tree> attempted to remove a directory, but failed. This may be because
some objects that were unable to be removed remain in the directory, or
it could be a permissions issue. The directory will be left behind.
=item cannot restore permissions of [dir] to [0nnn]: [errmsg]
After having failed to remove a directory, C<remove_tree> was unable to
restore its permissions from a permissive state back to a possibly
more restrictive setting. (Permissions given in octal).
=item cannot make file [file] writeable: [errmsg]
C<remove_tree> attempted to force the permissions of a file to ensure it
could be deleted, but failed to do so. It will, however, still attempt
to unlink the file.
=item cannot unlink file [file]: [errmsg]
C<remove_tree> failed to remove a file. Probably a permissions issue.
=item cannot restore permissions of [file] to [0nnn]: [errmsg]
After having failed to remove a file, C<remove_tree> was also unable
to restore the permissions on the file to a possibly less permissive
setting. (Permissions given in octal).
=item unable to map [owner] to a uid, ownership not changed");
C<make_path> was instructed to give the ownership of created
directories to the symbolic name [owner], but C<getpwnam> did
not return the corresponding numeric uid. The directory will
be created, but ownership will not be changed.
=item unable to map [group] to a gid, group ownership not changed
C<make_path> was instructed to give the group ownership of created
directories to the symbolic name [group], but C<getgrnam> did
not return the corresponding numeric gid. The directory will
be created, but group ownership will not be changed.
=back
=head1 SEE ALSO
=over 4
=item *
L<File::Remove>
Allows files and directories to be moved to the Trashcan/Recycle
Bin (where they may later be restored if necessary) if the operating
system supports such functionality. This feature may one day be
made available directly in C<File::Path>.
=item *
L<File::Find::Rule>
When removing directory trees, if you want to examine each file to
decide whether to delete it (and possibly leaving large swathes
alone), F<File::Find::Rule> offers a convenient and flexible approach
to examining directory trees.
=back
=head1 BUGS AND LIMITATIONS
The following describes F<File::Path> limitations and how to report bugs.
=head2 MULTITHREADED APPLICATIONS
F<File::Path> C<rmtree> and C<remove_tree> will not work with
multithreaded applications due to its use of C<chdir>. At this time,
no warning or error is generated in this situation. You will
certainly encounter unexpected results.
The implementation that surfaces this limitation will not be changed. See the
F<File::Path::Tiny> module for functionality similar to F<File::Path> but which does
not C<chdir>.
=head2 NFS Mount Points
F<File::Path> is not responsible for triggering the automounts, mirror mounts,
and the contents of network mounted filesystems. If your NFS implementation
requires an action to be performed on the filesystem in order for
F<File::Path> to perform operations, it is strongly suggested you assure
filesystem availability by reading the root of the mounted filesystem.
=head2 REPORTING BUGS
Please report all bugs on the RT queue, either via the web interface:
L<http://rt.cpan.org/NoAuth/Bugs.html?Dist=File-Path>
or by email:
[email protected]
In either case, please B<attach> patches to the bug report rather than
including them inline in the web post or the body of the email.
You can also send pull requests to the Github repository:
L<https://github.com/rpcme/File-Path>
=head1 ACKNOWLEDGEMENTS
Paul Szabo identified the race condition originally, and Brendan
O'Dea wrote an implementation for Debian that addressed the problem.
That code was used as a basis for the current code. Their efforts
are greatly appreciated.
Gisle Aas made a number of improvements to the documentation for
2.07 and his advice and assistance is also greatly appreciated.
Reini Urban modernized it for cperl, bumping its major version +1.
=head1 AUTHORS
Prior authors and maintainers: Tim Bunce, Charles Bailey, and
David Landgren <F<[email protected]>>.
Current maintainers are Richard Elberger <F<[email protected]>> and
James (Jim) Keenan <F<[email protected]>>.
=head1 CONTRIBUTORS
Contributors to File::Path, in alphabetical order by first name.
=over 1
=item <F<[email protected]>>
=item Charlie Gonzalez <F<[email protected]>>
=item Craig A. Berry <F<[email protected]>>
=item James E Keenan <F<[email protected]>>
=item John Lightsey <F<[email protected]>>
=item Nigel Horne <F<[email protected]>>
=item Reini Urban <F<[email protected]>>
=item Richard Elberger <F<[email protected]>>
=item Ryan Yee <F<[email protected]>>
=item Skye Shaw <F<[email protected]>>
=item Tom Lutz <F<[email protected]>>
=item Will Sheppard <F<willsheppard@github>>
=back
=head1 COPYRIGHT
This module is copyright (C) Charles Bailey, Tim Bunce, David Landgren,
James Keenan and Richard Elberger 1995-2018. All rights reserved.
=head1 LICENSE
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
=cut
| 33.770543 | 141 | 0.599968 |
edc8193eb95c67ac0c39674b85276629a83a0ba1 | 23,384 | pm | Perl | t/tests/TestsFor/Test/Class/Moose/History.pm | jimeUWOshkosh/test-class-moose-history | 3bc6dd85cd22ccccad8605e8bb4abce5dfd5cc49 | [
"Artistic-2.0",
"Unlicense"
] | null | null | null | t/tests/TestsFor/Test/Class/Moose/History.pm | jimeUWOshkosh/test-class-moose-history | 3bc6dd85cd22ccccad8605e8bb4abce5dfd5cc49 | [
"Artistic-2.0",
"Unlicense"
] | null | null | null | t/tests/TestsFor/Test/Class/Moose/History.pm | jimeUWOshkosh/test-class-moose-history | 3bc6dd85cd22ccccad8605e8bb4abce5dfd5cc49 | [
"Artistic-2.0",
"Unlicense"
] | null | null | null | package TestsFor::Test::Class::Moose::History;
use Test::Class::Moose extends => 'TestsFor::Base';
use namespace::autoclean;
sub test_basics {
my $test = shift;
my $runner = $test->fake_runner;
my $history = Test::Class::Moose::History->new(
runner => $test->fake_runner,
branch => 'some_branch',
commit => 'abcd1234',
database_file => ':memory:',
);
$history->save;
my $report = $history->report;
my %expected = (
last_test_status => [
[ 'TestsFor::Test::Class::Moose::History', 'test_basics', '0', 1
],
[ 'TestsFor::Test::Class::Moose::History::Report',
'test_basics', '0', 1
],
[ 'TestsFor::Test::Class::Moose::History',
'test_forced_failure', '0', 0
]
],
last_failures => [
[ 'TestsFor::Test::Class::Moose::History',
'test_forced_failure'
]
],
top_failures => [
[ 'TestsFor::Test::Class::Moose::History',
'test_forced_failure', '2017-03-23T14:43:48',
'2017-03-23T14:43:48', 1
]
],
);
foreach my $method ( sort keys %expected ) {
my $result = $report->$method;
eq_or_diff $result, $expected{$method},
"Report results for $method should be correct";
}
}
sub fake_runner {
my $test = shift;
no strict;
my $runner = eval <<'END';
$runner = bless( {
'_executor' => bless( {
'test_configuration' => bless( {
'builder' => bless( {
'Exported_To' => 'Test::Class::Moose::Role::Executor',
'Orig_Handles' => [
\*{'Test2::Formatter::TAP::$out'},
\*{'Test2::Formatter::TAP::$err'},
do{my $o}
],
'Original_Pid' => 61749,
'Stack' => bless( [
bless( {
'_formatter' => bless( {
'handles' => [
do{my $o},
do{my $o},
do{my $o}
],
'no_header' => 0,
'no_numbers' => ''
}, 'Test::Builder::Formatter' ),
'_meta' => {
'Test::Builder' => {
'Done_Testing' => [
'Moose::Meta::Method::Delegation',
'.../Moose/Meta/Method/Delegation.pm',
110,
'Test::Class::Moose::Executor::Sequential::runtests'
],
'Ending' => 0,
'Name' => 't/tcm.t',
'Skip_All' => 0,
'Test_Results' => [
{
'actual_ok' => 1,
'name' => 'TestsFor::Base',
'ok' => 1,
'reason' => 'Skipping \'TestsFor::Base\': no test methods found',
'type' => 'skip'
},
{
'actual_ok' => 0,
'name' => 'TestsFor::Test::Class::Moose::History',
'ok' => 0,
'reason' => '',
'type' => ''
},
{
'actual_ok' => 1,
'name' => 'TestsFor::Test::Class::Moose::History::Report',
'ok' => 1,
'reason' => '',
'type' => ''
}
]
}
},
'_passing' => 0,
'_plan' => 3,
'_pre_filters' => [
{
'code' => sub { "DUMMY" },
'inherit' => 1
}
],
'count' => 3,
'ended' => [
'Moose::Meta::Method::Delegation',
'.../Moose/Meta/Method/Delegation.pm',
110,
'Test::Class::Moose::Executor::Sequential::runtests'
],
'failed' => 1,
'hid' => '61749-0-1',
'no_ending' => 0,
'pid' => 61749,
'tid' => 0
}, 'Test2::Hub' )
], 'Test2::API::Stack' )
}, 'Test::Builder' ),
'randomize' => 0,
'randomize_classes' => 0,
'set_process_name' => 0,
'show_timing' => undef,
'statistics' => undef
}, 'Test::Class::Moose::Config' ),
'test_report' => bless( {
'_end_benchmark' => bless( [
'1490280228.94836',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.93922',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'is_parallel' => 0,
'num_test_methods' => 3,
'num_tests_run' => 3,
'test_classes' => [
bless( {
'_start_benchmark' => bless( [
'1490280228.9404',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'name' => 'TestsFor::Base',
'notes' => {},
'passed' => 0,
'test_instances' => [
bless( {
'name' => 'TestsFor::Base',
'notes' => {},
'passed' => 1,
'skipped' => 'Skipping \'TestsFor::Base\': no test methods found',
'test_methods' => []
}, 'Test::Class::Moose::Report::Instance' )
]
}, 'Test::Class::Moose::Report::Class' ),
bless( {
'_end_benchmark' => bless( [
'1490280228.9458',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94257',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'name' => 'TestsFor::Test::Class::Moose::History',
'notes' => {},
'passed' => 0,
'test_instances' => [
bless( {
'_end_benchmark' => bless( [
'1490280228.94578',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94279',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'name' => 'TestsFor::Test::Class::Moose::History',
'notes' => {},
'passed' => 0,
'test_methods' => [
bless( {
'_end_benchmark' => bless( [
'1490280228.94373',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94354',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_basics',
'notes' => {},
'num_tests_run' => 1,
'passed' => 1,
'test_setup_method' => bless( {
'_end_benchmark' => bless( [
'1490280228.94323',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94315',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_setup',
'notes' => {},
'num_tests_run' => 0,
'passed' => 0
}, 'Test::Class::Moose::Report::Method' ),
'test_teardown_method' => bless( {
'_end_benchmark' => bless( [
'1490280228.94417',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94409',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_teardown',
'notes' => {},
'num_tests_run' => 0,
'passed' => 0
}, 'Test::Class::Moose::Report::Method' ),
'tests_planned' => 1,
'time' => bless( {
'_timediff' => bless( [
'0.000190973281860352',
'0',
'0',
0,
0,
0
], 'Benchmark' ),
'user' => 0
}, 'Test::Class::Moose::Report::Time' )
}, 'Test::Class::Moose::Report::Method' ),
bless( {
'_end_benchmark' => bless( [
'1490280228.94506',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94461',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_forced_failure',
'notes' => {},
'num_tests_run' => 1,
'passed' => 0,
'test_setup_method' => bless( {
'_end_benchmark' => bless( [
'1490280228.94431',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94424',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_setup',
'notes' => {},
'num_tests_run' => 0,
'passed' => 0
}, 'Test::Class::Moose::Report::Method' ),
'test_teardown_method' => bless( {
'_end_benchmark' => bless( [
'1490280228.94565',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94557',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_teardown',
'notes' => {},
'num_tests_run' => 0,
'passed' => 0
}, 'Test::Class::Moose::Report::Method' ),
'tests_planned' => 1,
'time' => bless( {
'_timediff' => bless( [
'0.000454187393188477',
'0',
'0',
0,
0,
0
], 'Benchmark' ),
'user' => 0
}, 'Test::Class::Moose::Report::Time' )
}, 'Test::Class::Moose::Report::Method' )
],
'test_shutdown_method' => bless( {
'_end_benchmark' => bless( [
'1490280228.94578',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.9457',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_shutdown',
'notes' => {},
'num_tests_run' => 0,
'passed' => 0
}, 'Test::Class::Moose::Report::Method' ),
'test_startup_method' => bless( {
'_end_benchmark' => bless( [
'1490280228.94294',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94285',
'0.49',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_startup',
'notes' => {},
'num_tests_run' => 0,
'passed' => 0
}, 'Test::Class::Moose::Report::Method' )
}, 'Test::Class::Moose::Report::Instance' )
]
}, 'Test::Class::Moose::Report::Class' ),
bless( {
'_end_benchmark' => bless( [
'1490280228.94806',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94656',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'name' => 'TestsFor::Test::Class::Moose::History::Report',
'notes' => {},
'passed' => 1,
'test_instances' => [
bless( {
'_end_benchmark' => bless( [
'1490280228.94805',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94678',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'name' => 'TestsFor::Test::Class::Moose::History::Report',
'notes' => {},
'passed' => 1,
'test_methods' => [
bless( {
'_end_benchmark' => bless( [
'1490280228.94757',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94738',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_basics',
'notes' => {},
'num_tests_run' => 1,
'passed' => 1,
'test_setup_method' => bless( {
'_end_benchmark' => bless( [
'1490280228.94714',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94706',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_setup',
'notes' => {},
'num_tests_run' => 0,
'passed' => 0
}, 'Test::Class::Moose::Report::Method' ),
'test_teardown_method' => bless( {
'_end_benchmark' => bless( [
'1490280228.94793',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94785',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_teardown',
'notes' => {},
'num_tests_run' => 0,
'passed' => 0
}, 'Test::Class::Moose::Report::Method' ),
'tests_planned' => 1,
'time' => bless( {
'_timediff' => bless( [
'0.000189781188964844',
'0',
'0',
0,
0,
0
], 'Benchmark' ),
'user' => 0
}, 'Test::Class::Moose::Report::Time' )
}, 'Test::Class::Moose::Report::Method' )
],
'test_shutdown_method' => bless( {
'_end_benchmark' => bless( [
'1490280228.94804',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94797',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_shutdown',
'notes' => {},
'num_tests_run' => 0,
'passed' => 0
}, 'Test::Class::Moose::Report::Method' ),
'test_startup_method' => bless( {
'_end_benchmark' => bless( [
'1490280228.94689',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'_start_benchmark' => bless( [
'1490280228.94681',
'0.5',
'0.03',
'0',
'0',
0
], 'Benchmark' ),
'instance' => {},
'name' => 'test_startup',
'notes' => {},
'num_tests_run' => 0,
'passed' => 0
}, 'Test::Class::Moose::Report::Method' )
}, 'Test::Class::Moose::Report::Instance' )
]
}, 'Test::Class::Moose::Report::Class' )
]
}, 'Test::Class::Moose::Report' )
}, 'Test::Class::Moose::Executor::Sequential' ),
'color_output' => 1,
'jobs' => 1,
'test_configuration' => {}
}, 'Test::Class::Moose::Runner' );
$runner->{'_executor'}{'test_configuration'}{'builder'}{'Orig_Handles'}[2] = $runner->{'_executor'}{'test_configuration'}{'builder'}{'Orig_Handles'}[0];
$runner->{'_executor'}{'test_configuration'}{'builder'}{'Stack'}[0]{'_formatter'}{'handles'}[0] = $runner->{'_executor'}{'test_configuration'}{'builder'}{'Orig_Handles'}[0];
$runner->{'_executor'}{'test_configuration'}{'builder'}{'Stack'}[0]{'_formatter'}{'handles'}[1] = $runner->{'_executor'}{'test_configuration'}{'builder'}{'Orig_Handles'}[1];
$runner->{'_executor'}{'test_configuration'}{'builder'}{'Stack'}[0]{'_formatter'}{'handles'}[2] = $runner->{'_executor'}{'test_configuration'}{'builder'}{'Orig_Handles'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0]{'test_methods'}[0]{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0]{'test_methods'}[0]{'test_setup_method'}{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0]{'test_methods'}[0]{'test_teardown_method'}{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0]{'test_methods'}[1]{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0]{'test_methods'}[1]{'test_setup_method'}{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0]{'test_methods'}[1]{'test_teardown_method'}{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0]{'test_shutdown_method'}{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0]{'test_startup_method'}{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[1]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[2]{'test_instances'}[0]{'test_methods'}[0]{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[2]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[2]{'test_instances'}[0]{'test_methods'}[0]{'test_setup_method'}{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[2]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[2]{'test_instances'}[0]{'test_methods'}[0]{'test_teardown_method'}{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[2]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[2]{'test_instances'}[0]{'test_shutdown_method'}{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[2]{'test_instances'}[0];
$runner->{'_executor'}{'test_report'}{'test_classes'}[2]{'test_instances'}[0]{'test_startup_method'}{'instance'} = $runner->{'_executor'}{'test_report'}{'test_classes'}[2]{'test_instances'}[0];
$runner->{'test_configuration'} = $runner->{'_executor'}{'test_configuration'};
$runner
END
return $runner;
}
__PACKAGE__->meta->make_immutable;
1;
| 36.423676 | 213 | 0.354858 |
ed83beff5fab1dcab2849ef95ce82a448abb5c2b | 335 | t | Perl | t/00_authenticate.t | bentglasstube/WWW-Jawbone-Up | 3bce2d92babe9f20e0345fda9b522ff6ddb2eca5 | [
"MIT"
] | 1 | 2021-02-15T02:34:20.000Z | 2021-02-15T02:34:20.000Z | t/00_authenticate.t | bentglasstube/WWW-Jawbone-Up | 3bce2d92babe9f20e0345fda9b522ff6ddb2eca5 | [
"MIT"
] | null | null | null | t/00_authenticate.t | bentglasstube/WWW-Jawbone-Up | 3bce2d92babe9f20e0345fda9b522ff6ddb2eca5 | [
"MIT"
] | null | null | null | use strict;
use Test::More tests => 2;
use WWW::Jawbone::Up::Mock;
my $bad =
WWW::Jawbone::Up::Mock->connect('[email protected]', 'wrongpassword');
is($bad, undef, 'invalid credentials');
my $alan = WWW::Jawbone::Up::Mock->connect('[email protected]', 's3kr3t');
isa_ok($alan, 'WWW::Jawbone::Up', 'autentications successful');
| 25.769231 | 75 | 0.677612 |
ed86685f49e9536356be1de4017b6fc8eebc13c0 | 820 | t | Perl | t/009module/005dtm-struct-user.t | ChengCat/dale | 4a764895611679cd1670d9a43ffdbee136661759 | [
"BSD-3-Clause"
] | 1,083 | 2015-03-18T09:42:49.000Z | 2022-03-29T03:17:47.000Z | t/009module/005dtm-struct-user.t | ChengCat/dale | 4a764895611679cd1670d9a43ffdbee136661759 | [
"BSD-3-Clause"
] | 195 | 2015-01-04T03:06:41.000Z | 2022-03-18T18:16:27.000Z | t/009module/005dtm-struct-user.t | ChengCat/dale | 4a764895611679cd1670d9a43ffdbee136661759 | [
"BSD-3-Clause"
] | 56 | 2015-03-18T20:02:13.000Z | 2022-01-22T19:35:27.000Z | #!/usr/bin/env perl
use warnings;
use strict;
$ENV{"DALE_TEST_ARGS"} ||= "";
my $test_dir = $ENV{"DALE_TEST_DIR"} || ".";
$ENV{PATH} .= ":.";
use Data::Dumper;
use Test::More tests => 4;
my @res = `dalec -O0 $test_dir/t/src/dtm-struct.dt -o ./t.dtm-struct-user.o -c -m ./dtm-struct`;
is_deeply(\@res, [], 'no compilation errors');
@res = `dalec $ENV{"DALE_TEST_ARGS"} $test_dir/t/src/dtm-struct-user.dt -o dtm-struct-user `;
is_deeply(\@res, [], 'no compilation errors');
@res = `./dtm-struct-user`;
is($?, 0, 'Program executed successfully');
chomp for @res;
is_deeply(\@res,
[ '10 c 20' ],
'Got correct results');
`rm libdtm-struct.so`;
`rm libdtm-struct-nomacros.so`;
`rm libdtm-struct.dtm`;
`rm libdtm-struct.bc`;
`rm libdtm-struct-nomacros.bc`;
`rm dtm-struct-user`;
`rm t.dtm-struct-user.o`;
1;
| 22.777778 | 96 | 0.639024 |
ed83d7190ab3ea615d5cf707084e5a0ea79e1316 | 2,772 | t | Perl | t/ack-f.t | packy/ack2 | bbf32df850cf1c7ceed0445db7f05c24710f6e8a | [
"Artistic-2.0"
] | 1 | 2017-08-17T06:10:50.000Z | 2017-08-17T06:10:50.000Z | t/ack-f.t | Acidburn0zzz/ack3 | 5659ec990055ba91b86bc028a2b0c4dc28d81ec9 | [
"Artistic-2.0"
] | null | null | null | t/ack-f.t | Acidburn0zzz/ack3 | 5659ec990055ba91b86bc028a2b0c4dc28d81ec9 | [
"Artistic-2.0"
] | null | null | null | #!perl -T
use warnings;
use strict;
use Test::More tests => 6;
use lib 't';
use Util;
prep_environment();
DEFAULT_DIR_EXCLUSIONS: {
my @expected = ( qw(
t/swamp/0
t/swamp/c-header.h
t/swamp/c-source.c
t/swamp/crystallography-weenies.f
t/swamp/example.R
t/swamp/file.bar
t/swamp/file.foo
t/swamp/fresh.css
t/swamp/groceries/another_subdir/fruit
t/swamp/groceries/another_subdir/junk
t/swamp/groceries/another_subdir/meat
t/swamp/groceries/dir.d/fruit
t/swamp/groceries/dir.d/junk
t/swamp/groceries/dir.d/meat
t/swamp/groceries/fruit
t/swamp/groceries/junk
t/swamp/groceries/meat
t/swamp/groceries/subdir/fruit
t/swamp/groceries/subdir/junk
t/swamp/groceries/subdir/meat
t/swamp/html.htm
t/swamp/html.html
t/swamp/incomplete-last-line.txt
t/swamp/javascript.js
t/swamp/lua-shebang-test
t/swamp/Makefile
t/swamp/Makefile.PL
t/swamp/MasterPage.master
t/swamp/notaMakefile
t/swamp/notaRakefile
t/swamp/notes.md
t/swamp/options-crlf.pl
t/swamp/options.pl
t/swamp/parrot.pir
t/swamp/perl-test.t
t/swamp/perl-without-extension
t/swamp/perl.cgi
t/swamp/perl.handler.pod
t/swamp/perl.pl
t/swamp/perl.pm
t/swamp/perl.pod
t/swamp/pipe-stress-freaks.F
t/swamp/Rakefile
t/swamp/Sample.ascx
t/swamp/Sample.asmx
t/swamp/sample.asp
t/swamp/sample.aspx
t/swamp/sample.rake
t/swamp/service.svc
t/swamp/stuff.cmake
t/swamp/CMakeLists.txt
t/swamp/swamp/ignoreme.txt
),
't/swamp/not-an-#emacs-workfile#',
);
my @args = qw( -f t/swamp );
ack_sets_match( [ @args ], \@expected, 'DEFAULT_DIR_EXCLUSIONS' );
is( get_rc(), 0, '-f with matches exits with 0' );
}
COMBINED_FILTERS: {
my @expected = qw(
t/swamp/0
t/swamp/perl.pm
t/swamp/Rakefile
t/swamp/options-crlf.pl
t/swamp/options.pl
t/swamp/perl-without-extension
t/swamp/perl.cgi
t/swamp/Makefile.PL
t/swamp/perl-test.t
t/swamp/perl.handler.pod
t/swamp/perl.pl
t/swamp/perl.pod
);
my @args = qw( -f t/swamp --perl --rake );
ack_sets_match( [ @args ], \@expected, 'COMBINED_FILTERS' );
is( get_rc(), 0, '-f with matches exits with 0' );
}
EXIT_CODE: {
my @expected;
my @args = qw( -f t/swamp --type-add=baz:ext:baz --baz );
ack_sets_match( \@args, \@expected, 'EXIT_CODE' );
is( get_rc(), 1, '-f with no matches exits with 1' );
}
done_testing();
| 25.431193 | 70 | 0.586941 |
ed0e6ec3e4d474af82326bf3630a3fa12e094fa9 | 595 | pm | Perl | lib/Model/Schema/Result/PersonTrack.pm | ispyhumanfly/dirtybarfly | 1ddf831e2a0f325e2e156659479bebcad9a825ed | [
"MIT"
] | null | null | null | lib/Model/Schema/Result/PersonTrack.pm | ispyhumanfly/dirtybarfly | 1ddf831e2a0f325e2e156659479bebcad9a825ed | [
"MIT"
] | null | null | null | lib/Model/Schema/Result/PersonTrack.pm | ispyhumanfly/dirtybarfly | 1ddf831e2a0f325e2e156659479bebcad9a825ed | [
"MIT"
] | null | null | null | package Model::Schema::Result::PersonTrack;
use DBIx::Class::Candy -components => ['InflateColumn::DateTime'];
table 'person_track';
column track_id => {
data_type => 'int',
is_auto_increment => 1,
};
column comment => {
data_type => 'varchar',
size => 100,
};
column link => {
data_type => 'varchar',
size => 100,
};
column person => {
data_type => 'int',
};
column datetime => {
data_type => 'datetime',
size => 50,
};
primary_key 'track_id';
belongs_to person => 'Model::Schema::Result::Person';
1;
| 14.875 | 66 | 0.559664 |
eda372cdc6651ec7d1145e50e9215968fdb63e52 | 3,141 | pm | Perl | lib/InfoGopher/InfoSource/Zimbra.pm | devcon2012/infogopher | 81c88ca34629f0a738cd4db3c2dba89fe57d1a11 | [
"Artistic-1.0-Perl"
] | null | null | null | lib/InfoGopher/InfoSource/Zimbra.pm | devcon2012/infogopher | 81c88ca34629f0a738cd4db3c2dba89fe57d1a11 | [
"Artistic-1.0-Perl"
] | 1 | 2019-11-20T22:03:04.000Z | 2019-11-23T22:06:49.000Z | lib/InfoGopher/InfoSource/Zimbra.pm | devcon2012/infogopher | 81c88ca34629f0a738cd4db3c2dba89fe57d1a11 | [
"Artistic-1.0-Perl"
] | null | null | null | package InfoGopher::InfoSource::Zimbra ;
# Fetch updates from Zimbra API
#
# InfoGopher - A framework for collecting information
#
# (c) Klaus Ramstöck [email protected] 2019
#
# You can use and distribute this software under the same conditions as perl
#
use strict ;
use warnings ;
use utf8 ;
use namespace::autoclean ;
use Devel::StealthDebug ENABLE => $ENV{dbg_zimbra} || $ENV{dbg_source} ;
use Data::Dumper ;
use URL::Encode qw ( url_encode ) ;
use Moose ;
use Try::Tiny ;
use InfoGopher::Essentials ;
extends 'InfoGopher::InfoSource::HTTPSInfoSource' ;
with 'InfoGopher::InfoSource::_InfoSource' ;
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Members
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
has 'auth_token' => (
documentation => 'zimbra auth token',
is => 'rw',
isa => 'Maybe[Str]',
) ;
sub _build_expected_mimetype
{
return 'application/json' ;
}
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Methods
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# -----------------------------------------------------------------------------
# fetch - get fresh copy from RSS InfoSource
#
#
sub fetch
{
my ($self) = @_ ;
my $name = $self -> name ;
my $i = NewIntention ( "Fetch Zimbra $name:" . $self -> uri ) ;
my $jar = $self -> cookie_jar ;
my $version = 0 ;
my $key = "ZM_AUTH_TOKEN" ;
my $val = $self -> auth_token ;
my $path = "/" ;
my $domain = $self -> host ;
my $port = $self -> port ;
my $path_spec = 1 ;
my $secure = 1 ;
my $maxage = 3600 ;
my $discard = 0 ;
my %rest ;
$jar->set_cookie( $version, $key, $val, $path, $domain, $port, $path_spec, $secure, $maxage, $discard, \%rest ) ;
# The set_cookie() method updates the state of the $cookie_jar. The $key, $val, $domain, $port and $path arguments
# are strings. The $path_spec, $secure, $discard arguments are boolean values. The $maxage value is a number
# indicating number of seconds that this cookie will live. A value of $maxage <= 0 will delete this cookie.
# The $version argument sets the version of the cookie; the default value is 0 ( original Netscape spec ).
# Setting $version to another value indicates the RFC to which the cookie conforms (e.g. version 1 for RFC 2109).
# %rest defines various other attributes like "Comment" and "CommentURL".
$self -> get_https ( ) ;
$self -> info_bites -> clear () ;
# copy my id to bites so consumer can later track its source
$self -> info_bites -> source_name ( $self -> name ) ;
$self -> info_bites -> source_id ( $self -> id ) ;
my $newbite = $self -> add_info_bite (
$self -> raw,
'application/json',
time ) ;
return ;
}
__PACKAGE__ -> meta -> make_immutable ;
1;
=pod
=cut
| 29.632075 | 119 | 0.510984 |
edaefc2bdfa7efe7d847c4ef18d14610982077cf | 322 | t | Perl | t/18_perl514.t | bayashi/Test-Arrow | fabec15f66da34377efe28a7724d1192a942ec9d | [
"Artistic-2.0"
] | 2 | 2020-02-23T08:53:17.000Z | 2020-07-11T15:59:35.000Z | t/18_perl514.t | manwar/Test-Arrow | 4a38ce9a739c08b28e91e3a47b6c7c7367975e3e | [
"Artistic-2.0"
] | 15 | 2020-02-18T17:57:01.000Z | 2020-04-24T05:15:11.000Z | t/18_perl514.t | manwar/Test-Arrow | 4a38ce9a739c08b28e91e3a47b6c7c7367975e3e | [
"Artistic-2.0"
] | 2 | 2020-02-18T17:36:46.000Z | 2020-04-26T11:44:22.000Z | use strict;
use warnings;
{
# For under Perl 5.14
# Perl 5.14 or later, it's has been loaded IO::Handle
require Test::Arrow;
no strict 'refs'; ## no critic
no warnings 'redefine';
*{'Test::Arrow::_need_io_handle'} = sub { !!1 };
Test::Arrow->import;
}
t()->ok($INC{"IO/Handle.pm"});
done();
| 18.941176 | 57 | 0.590062 |
ed536a3408ac1556c9f7943ff9ab3f40e27763e1 | 2,001 | pm | Perl | auto-lib/Paws/CloudSearch/DescribeAvailabilityOptions.pm | agimenez/aws-sdk-perl | 9c4dff7d1af2ff0210c28ca44fb9e92bc625712b | [
"Apache-2.0"
] | 2 | 2016-09-22T09:18:33.000Z | 2017-06-20T01:36:58.000Z | auto-lib/Paws/CloudSearch/DescribeAvailabilityOptions.pm | cah-rfelsburg/paws | de9ffb8d49627635a2da588066df26f852af37e4 | [
"Apache-2.0"
] | null | null | null | auto-lib/Paws/CloudSearch/DescribeAvailabilityOptions.pm | cah-rfelsburg/paws | de9ffb8d49627635a2da588066df26f852af37e4 | [
"Apache-2.0"
] | null | null | null |
package Paws::CloudSearch::DescribeAvailabilityOptions;
use Moose;
has Deployed => (is => 'ro', isa => 'Bool');
has DomainName => (is => 'ro', isa => 'Str', required => 1);
use MooseX::ClassAttribute;
class_has _api_call => (isa => 'Str', is => 'ro', default => 'DescribeAvailabilityOptions');
class_has _returns => (isa => 'Str', is => 'ro', default => 'Paws::CloudSearch::DescribeAvailabilityOptionsResponse');
class_has _result_key => (isa => 'Str', is => 'ro', default => 'DescribeAvailabilityOptionsResult');
1;
### main pod documentation begin ###
=head1 NAME
Paws::CloudSearch::DescribeAvailabilityOptions - Arguments for method DescribeAvailabilityOptions on Paws::CloudSearch
=head1 DESCRIPTION
This class represents the parameters used for calling the method DescribeAvailabilityOptions on the
Amazon CloudSearch service. Use the attributes of this class
as arguments to method DescribeAvailabilityOptions.
You shouldn't make instances of this class. Each attribute should be used as a named argument in the call to DescribeAvailabilityOptions.
As an example:
$service_obj->DescribeAvailabilityOptions(Att1 => $value1, Att2 => $value2, ...);
Values for attributes that are native types (Int, String, Float, etc) can passed as-is (scalar values). Values for complex Types (objects) can be passed as a HashRef. The keys and values of the hashref will be used to instance the underlying object.
=head1 ATTRIBUTES
=head2 Deployed => Bool
Whether to display the deployed configuration (C<true>) or include any
pending changes (C<false>). Defaults to C<false>.
=head2 B<REQUIRED> DomainName => Str
The name of the domain you want to describe.
=head1 SEE ALSO
This class forms part of L<Paws>, documenting arguments for method DescribeAvailabilityOptions in L<Paws::CloudSearch>
=head1 BUGS and CONTRIBUTIONS
The source code is located here: https://github.com/pplu/aws-sdk-perl
Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
=cut
| 31.761905 | 249 | 0.749125 |
edd265a836e36d20e511b6d7aba24867e0b67252 | 27,554 | pm | Perl | lib/Dancer2/Test.pm | drforr/perl6-Dancer2 | 89f50f57cf305ed80777cd62c3d7a6c94150c9c8 | [
"Artistic-2.0"
] | null | null | null | lib/Dancer2/Test.pm | drforr/perl6-Dancer2 | 89f50f57cf305ed80777cd62c3d7a6c94150c9c8 | [
"Artistic-2.0"
] | null | null | null | lib/Dancer2/Test.pm | drforr/perl6-Dancer2 | 89f50f57cf305ed80777cd62c3d7a6c94150c9c8 | [
"Artistic-2.0"
] | null | null | null | package Dancer2::Test;
# ABSTRACT: Useful routines for testing Dancer2 apps
$Dancer2::Test::VERSION = '0.160003';
use strict;
use warnings;
use Carp qw<carp croak>;
use Test::More;
use Test::Builder;
use URI::Escape;
use Data::Dumper;
use File::Temp;
use parent 'Exporter';
our @EXPORT = qw(
dancer_response
response_content_is
response_content_isnt
response_content_is_deeply
response_content_like
response_content_unlike
response_status_is
response_status_isnt
response_headers_include
response_headers_are_deeply
response_is_file
route_exists
route_doesnt_exist
is_pod_covered
route_pod_coverage
);
#dancer1 also has read_logs, response_redirect_location_is
#cf. https://github.com/PerlDancer2/Dancer22/issues/25
use Dancer2::Core::Dispatcher;
use Dancer2::Core::Request;
# singleton to store all the apps
my $_dispatcher = Dancer2::Core::Dispatcher->new;
# prevent deprecation warnings
our $NO_WARN = 0;
# can be called with the ($method, $path, $option) triplet,
# or can be fed a request object directly, or can be fed
# a single string, assumed to be [ GET => $string ]
# or can be fed a response (which is passed through without
# any modification)
sub dancer_response {
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
_find_dancer_apps_for_dispatcher();
# useful for the high-level tests
return $_[0] if ref $_[0] eq 'Dancer2::Core::Response';
my ( $request, $env ) =
ref $_[0] eq 'Dancer2::Core::Request'
? _build_env_from_request(@_)
: _build_request_from_env(@_);
# override the set_request so it actually sets our request instead
{
no warnings qw<redefine once>;
*Dancer2::Core::App::set_request = sub {
my $self = shift;
$self->{'request'} = $request;
};
}
# since the response is a PSGI response
# we create a Response object which was originally expected
my $psgi_response = $_dispatcher->dispatch($env);
return Dancer2::Core::Response->new(
status => $psgi_response->[0],
headers => $psgi_response->[1],
content => $psgi_response->[2][0],
);
}
sub _build_request_from_env {
# arguments can be passed as the triplet
# or as a arrayref, or as a simple string
my ( $method, $path, $options ) =
@_ > 1 ? @_
: ref $_[0] eq 'ARRAY' ? @{ $_[0] }
: ( GET => $_[0], {} );
my $env = {
%ENV,
REQUEST_METHOD => uc($method),
PATH_INFO => $path,
QUERY_STRING => '',
'psgi.url_scheme' => 'http',
SERVER_PROTOCOL => 'HTTP/1.0',
SERVER_NAME => 'localhost',
SERVER_PORT => 3000,
HTTP_HOST => 'localhost',
HTTP_USER_AGENT => "Dancer2::Test simulator v " . Dancer2->VERSION,
};
if ( defined $options->{params} ) {
my @params;
while ( my ( $p, $value ) = each %{ $options->{params} } ) {
if ( ref($value) eq 'ARRAY' ) {
for my $v (@$value) {
push @params,
uri_escape_utf8($p) . '=' . uri_escape_utf8($v);
}
}
else {
push @params,
uri_escape_utf8($p) . '=' . uri_escape_utf8($value);
}
}
$env->{QUERY_STRING} = join( '&', @params );
}
my $request = Dancer2::Core::Request->new( env => $env );
# body
$request->body( $options->{body} ) if exists $options->{body};
# headers
if ( $options->{headers} ) {
for my $header ( @{ $options->{headers} } ) {
my ( $name, $value ) = @{$header};
$request->header( $name => $value );
}
}
# files
if ( $options->{files} ) {
for my $file ( @{ $options->{files} } ) {
my $headers = $file->{headers};
$headers->{'Content-Type'} ||= 'text/plain';
my $temp = File::Temp->new();
if ( $file->{data} ) {
print $temp $file->{data};
close($temp);
}
else {
require File::Copy;
File::Copy::copy( $file->{filename}, $temp );
}
my $upload = Dancer2::Core::Request::Upload->new(
filename => $file->{filename},
size => -s $temp->filename,
tempname => $temp->filename,
headers => $headers,
);
## keep temp_fh in scope so it doesn't get deleted too early
## But will get deleted by the time the test is finished.
$upload->{temp_fh} = $temp;
$request->uploads->{ $file->{name} } = $upload;
}
}
# content-type
if ( $options->{content_type} ) {
$request->content_type( $options->{content_type} );
}
return ( $request, $env );
}
sub _build_env_from_request {
my ($request) = @_;
my $env = {
REQUEST_METHOD => $request->method,
PATH_INFO => $request->path,
QUERY_STRING => '',
'psgi.url_scheme' => 'http',
SERVER_PROTOCOL => 'HTTP/1.0',
SERVER_NAME => 'localhost',
SERVER_PORT => 3000,
HTTP_HOST => 'localhost',
HTTP_USER_AGENT => "Dancer2::Test simulator v" . Dancer2->VERSION,
};
# TODO
if ( my $params = $request->{_query_params} ) {
my @params;
while ( my ( $p, $value ) = each %{$params} ) {
if ( ref($value) eq 'ARRAY' ) {
for my $v (@$value) {
push @params,
uri_escape_utf8($p) . '=' . uri_escape_utf8($v);
}
}
else {
push @params,
uri_escape_utf8($p) . '=' . uri_escape_utf8($value);
}
}
$env->{QUERY_STRING} = join( '&', @params );
}
# TODO files
return ( $request, $env );
}
sub response_status_is {
my ( $req, $status, $test_name ) = @_;
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
$test_name ||= "response status is $status for " . _req_label($req);
my $response = dancer_response($req);
my $tb = Test::Builder->new;
local $Test::Builder::Level = $Test::Builder::Level + 1;
$tb->is_eq( $response->[0], $status, $test_name );
}
sub _find_route_match {
my ( $request, $env ) =
ref $_[0] eq 'Dancer2::Core::Request'
? _build_env_from_request(@_)
: _build_request_from_env(@_);
for my $app (@{$_dispatcher->apps}) {
for my $route (@{$app->routes->{lc($request->method)}}) {
if ( $route->match($request) ) {
return 1;
}
}
}
return 0;
}
sub route_exists {
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
my $tb = Test::Builder->new;
local $Test::Builder::Level = $Test::Builder::Level + 1;
$tb->ok( _find_route_match($_[0]), $_[1]);
}
sub route_doesnt_exist {
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
my $tb = Test::Builder->new;
local $Test::Builder::Level = $Test::Builder::Level + 1;
$tb->ok( !_find_route_match($_[0]), $_[1]);
}
sub response_status_isnt {
my ( $req, $status, $test_name ) = @_;
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
$test_name ||= "response status is not $status for " . _req_label($req);
my $response = dancer_response($req);
my $tb = Test::Builder->new;
local $Test::Builder::Level = $Test::Builder::Level + 1;
$tb->isnt_eq( $response->[0], $status, $test_name );
}
{
# Map comparison operator names to human-friendly ones
my %cmp_name = (
is_eq => "is",
isnt_eq => "is not",
like => "matches",
unlike => "doesn't match",
);
sub _cmp_response_content {
my ( $req, $want, $test_name, $cmp ) = @_;
if ( @_ == 3 ) {
$cmp = $test_name;
$test_name = $cmp_name{$cmp};
$test_name =
"response content $test_name $want for " . _req_label($req);
}
my $response = dancer_response($req);
my $tb = Test::Builder->new;
local $Test::Builder::Level = $Test::Builder::Level + 1;
$tb->$cmp( $response->[2][0], $want, $test_name );
}
}
sub response_content_is {
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
local $Test::Builder::Level = $Test::Builder::Level + 1;
_cmp_response_content( @_, 'is_eq' );
}
sub response_content_isnt {
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
local $Test::Builder::Level = $Test::Builder::Level + 1;
_cmp_response_content( @_, 'isnt_eq' );
}
sub response_content_like {
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
local $Test::Builder::Level = $Test::Builder::Level + 1;
_cmp_response_content( @_, 'like' );
}
sub response_content_unlike {
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
local $Test::Builder::Level = $Test::Builder::Level + 1;
_cmp_response_content( @_, 'unlike' );
}
sub response_content_is_deeply {
my ( $req, $matcher, $test_name ) = @_;
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
$test_name ||= "response content looks good for " . _req_label($req);
local $Test::Builder::Level = $Test::Builder::Level + 1;
my $response = _req_to_response($req);
is_deeply $response->[2][0], $matcher, $test_name;
}
sub response_is_file {
my ( $req, $test_name ) = @_;
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
$test_name ||= "a file is returned for " . _req_label($req);
my $response = _get_file_response($req);
my $tb = Test::Builder->new;
local $Test::Builder::Level = $Test::Builder::Level + 1;
return $tb->ok( defined($response), $test_name );
}
sub response_headers_are_deeply {
my ( $req, $expected, $test_name ) = @_;
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
$test_name ||= "headers are as expected for " . _req_label($req);
local $Test::Builder::Level = $Test::Builder::Level + 1;
my $response = dancer_response( _expand_req($req) );
is_deeply(
_sort_headers( $response->[1] ),
_sort_headers($expected), $test_name
);
}
sub response_headers_include {
my ( $req, $expected, $test_name ) = @_;
carp 'Dancer2::Test is deprecated, please use Plack::Test instead'
unless $NO_WARN;
$test_name ||= "headers include expected data for " . _req_label($req);
my $tb = Test::Builder->new;
my $response = dancer_response($req);
local $Test::Builder::Level = $Test::Builder::Level + 1;
print STDERR "Headers are: "
. Dumper( $response->[1] )
. "\n Expected to find header: "
. Dumper($expected)
if !$tb->ok(
_include_in_headers( $response->[1], $expected ),
$test_name
);
}
sub route_pod_coverage {
require Pod::Simple::Search;
require Pod::Simple::SimpleTree;
my $all_routes = {};
foreach my $app ( @{ $_dispatcher->apps } ) {
my $routes = $app->routes;
my $available_routes = [];
foreach my $method ( sort { $b cmp $a } keys %$routes ) {
foreach my $r ( @{ $routes->{$method} } ) {
# we don't need pod coverage for head
next if $method eq 'head';
push @$available_routes, $method . ' ' . $r->spec_route;
}
}
## copy dereferenced array
$all_routes->{ $app->name }{routes} = [@$available_routes]
if @$available_routes;
# Pod::Simple v3.30 excluded the current directory even when in @INC.
# include the current directory as a search path; its backwards compatible
# with previous version.
my $undocumented_routes = [];
my $file = Pod::Simple::Search->new->find( $app->name, '.' );
if ($file) {
$all_routes->{ $app->name }{has_pod} = 1;
my $parser = Pod::Simple::SimpleTree->new->parse_file($file);
my $pod_dataref = $parser->root;
my $found_routes = {};
for ( my $i = 0; $i < @$available_routes; $i++ ) {
my $r = $available_routes->[$i];
my $app_string = lc $r;
$app_string =~ s/\*/_REPLACED_STAR_/g;
for ( my $idx = 0; $idx < @$pod_dataref; $idx++ ) {
my $pod_part = $pod_dataref->[$idx];
next if ref $pod_part ne 'ARRAY';
foreach my $ref_part (@$pod_part) {
if ( ref($ref_part) eq "ARRAY" ) {
push @$pod_dataref, $ref_part;
}
}
my $pod_string = lc $pod_part->[2];
$pod_string =~ s/['|"|\s]+/ /g;
$pod_string =~ s/\s$//g;
$pod_string =~ s/\*/_REPLACED_STAR_/g;
if ( $pod_string =~ m/^$app_string$/ ) {
$found_routes->{$app_string} = 1;
next;
}
}
if ( !$found_routes->{$app_string} ) {
push @$undocumented_routes, $r;
}
}
}
else { ### no POD found
$all_routes->{ $app->name }{has_pod} = 0;
}
if (@$undocumented_routes) {
$all_routes->{ $app->name }{undocumented_routes} =
$undocumented_routes;
}
elsif ( !$all_routes->{ $app->name }{has_pod}
&& @{ $all_routes->{ $app->name }{routes} } )
{
## copy dereferenced array
$all_routes->{ $app->name }{undocumented_routes} =
[ @{ $all_routes->{ $app->name }{routes} } ];
}
}
return $all_routes;
}
sub is_pod_covered {
my ($test_name) = @_;
$test_name ||= "is pod covered";
my $route_pod_coverage = route_pod_coverage();
my $tb = Test::Builder->new;
local $Test::Builder::Level = $Test::Builder::Level + 1;
foreach my $app ( @{ $_dispatcher->apps } ) {
my %undocumented_route =
( map { $_ => 1 }
@{ $route_pod_coverage->{ $app->name }{undocumented_routes} } );
$tb->subtest(
$app->name . $test_name,
sub {
foreach my $route (
@{ $route_pod_coverage->{ $app->name }{routes} } )
{
ok( !$undocumented_route{$route}, "$route is documented" );
}
}
);
}
}
sub import {
my ( $class, %options ) = @_;
my @applications;
if ( ref $options{apps} eq ref( [] ) ) {
@applications = @{ $options{apps} };
}
else {
my ( $caller, $script ) = caller;
# if no app is passed, assume the caller is one.
@applications = ($caller) if $caller->can('dancer_app');
}
# register the apps to the test dispatcher
$_dispatcher->apps( [ map {
$_->dancer_app->finish();
$_->dancer_app;
} @applications ] );
$class->export_to_level( 1, $class, @EXPORT );
}
# private
sub _req_label {
my $req = shift;
return
ref $req eq 'Dancer2::Core::Response' ? 'response object'
: ref $req eq 'Dancer2::Core::Request'
? join( ' ', map { $req->$_ } qw/ method path / )
: ref $req eq 'ARRAY' ? join( ' ', @$req )
: "GET $req";
}
sub _expand_req {
my $req = shift;
return ref $req eq 'ARRAY' ? @$req : ( 'GET', $req );
}
# Sort arrayref of headers (turn it into a list of arrayrefs, sort by the header
# & value, then turn it back into an arrayref)
sub _sort_headers {
my @originalheaders = @{ shift() }; # take a copy we can modify
my @headerpairs;
while ( my ( $header, $value ) = splice @originalheaders, 0, 2 ) {
push @headerpairs, [ $header, $value ];
}
# We have an array of arrayrefs holding header => value pairs; sort them by
# header then value, and return them flattened back into an arrayref
return [
map {@$_}
sort { $a->[0] cmp $b->[0] || $a->[1] cmp $b->[1] } @headerpairs
];
}
# make sure the given header sublist is included in the full headers array
sub _include_in_headers {
my ( $full_headers, $expected_subset ) = @_;
# walk through all the expected header pairs, make sure
# they exist with the same value in the full_headers list
# return false as soon as one is not.
for ( my $i = 0; $i < scalar(@$expected_subset); $i += 2 ) {
my ( $name, $value ) =
( $expected_subset->[$i], $expected_subset->[ $i + 1 ] );
return 0
unless _check_header( $full_headers, $name, $value );
}
# we've found all the expected pairs in the $full_headers list
return 1;
}
sub _check_header {
my ( $headers, $key, $value ) = @_;
for ( my $i = 0; $i < scalar(@$headers); $i += 2 ) {
my ( $name, $val ) = ( $headers->[$i], $headers->[ $i + 1 ] );
return 1 if $name eq $key && $value eq $val;
}
return 0;
}
sub _req_to_response {
my $req = shift;
# already a response object
return $req if ref $req eq 'Dancer2::Core::Response';
return dancer_response( ref $req eq 'ARRAY' ? @$req : ( 'GET', $req ) );
}
# make sure we have at least one app in the dispatcher, and if not,
# we must have at this point an app within the caller
sub _find_dancer_apps_for_dispatcher {
return if scalar( @{ $_dispatcher->apps } );
for ( my $deep = 0; $deep < 5; $deep++ ) {
my $caller = caller($deep);
next if !$caller || !$caller->can('dancer_app');
return $_dispatcher->apps( [ $caller->dancer_app ] );
}
croak "Unable to find a Dancer2 app, did you use Dancer2 in your test?";
}
1;
__END__
=pod
=encoding UTF-8
=head1 NAME
Dancer2::Test - Useful routines for testing Dancer2 apps
=head1 VERSION
version 0.160003
=head1 SYNOPSIS
use Test::More;
use Plack::Test;
use HTTP::Request::Common; # install separately
use YourDancerApp;
my $app = YourDancerApp->to_app;
my $test = Plack::Test->create($app);
my $res = $test->request( GET '/' );
is( $res->code, 200, '[GET /] Request successful' );
like( $res->content, qr/hello, world/, '[GET /] Correct content';
done_testing;
=head1 DESCRIPTION
B<DEPRECATED>. Please use L<Plack::Test> instead as shown in the SYNOPSIS!
This module will warn for a while until we actually remove it. This is to
provide enough time to fully remove it from your system.
If you need to remove the warnings, for now, you can set:
$Dancer::Test::NO_WARN = 1;
This module provides useful routines to test Dancer2 apps. They are, however,
buggy and unnecessary. L<Plack::Test> is advised instead.
$test_name is always optional.
=head1 FUNCTIONS
=head2 dancer_response ($method, $path, $params, $arg_env);
Returns a Dancer2::Core::Response object for the given request.
Only $method and $path are required.
$params is a hashref with 'body' as a string; 'headers' can be an arrayref or
a HTTP::Headers object, 'files' can be arrayref of hashref, containing some
files to upload:
dancer_response($method, $path,
{
params => $params,
body => $body,
headers => $headers,
files => [ { filename => '/path/to/file', name => 'my_file' } ],
}
);
A good reason to use this function is for testing POST requests. Since POST
requests may not be idempotent, it is necessary to capture the content and
status in one shot. Calling the response_status_is and response_content_is
functions in succession would make two requests, each of which could alter the
state of the application and cause Schrodinger's cat to die.
my $response = dancer_response POST => '/widgets';
is $response->status, 202, "response for POST /widgets is 202";
is $response->content, "Widget #1 has been scheduled for creation",
"response content looks good for first POST /widgets";
$response = dancer_response POST => '/widgets';
is $response->status, 202, "response for POST /widgets is 202";
is $response->content, "Widget #2 has been scheduled for creation",
"response content looks good for second POST /widgets";
It's possible to test file uploads:
post '/upload' => sub { return upload('image')->content };
$response = dancer_response(POST => '/upload', {files => [{name => 'image', filename => '/path/to/image.jpg'}]});
In addition, you can supply the file contents as the C<data> key:
my $data = 'A test string that will pretend to be file contents.';
$response = dancer_response(POST => '/upload', {
files => [{name => 'test', filename => "filename.ext", data => $data}]
});
You can also supply a hashref of headers:
headers => { 'Content-Type' => 'text/plain' }
=head2 response_status_is ($request, $expected, $test_name);
Asserts that Dancer2's response for the given request has a status equal to the
one given.
response_status_is [GET => '/'], 200, "response for GET / is 200";
=head2 route_exists([$method, $path], $test_name)
Asserts that the given request matches a route handler in Dancer2's
registry. If the route would have returned a 404, the route still exists
and this test will pass.
Note that because Dancer2 uses the default route handler
L<Dancer2::Handler::File> to match files in the public folder when
no other route matches, this test will always pass.
You can disable the default route handlers in the configs but you probably
want L<Dancer2::Test/response_status_is> or L<Dancer2::Test/dancer_response>
route_exists [GET => '/'], "GET / is handled";
=head2 route_doesnt_exist([$method, $path], $test_name)
Asserts that the given request does not match any route handler
in Dancer2's registry.
Note that this test is likely to always fail as any route not matched will
be handled by the default route handler in L<Dancer2::Handler::File>.
This can be disabled in the configs.
route_doesnt_exist [GET => '/bogus_path'], "GET /bogus_path is not handled";
=head2 response_status_isnt([$method, $path], $status, $test_name)
Asserts that the status of Dancer2's response is not equal to the
one given.
response_status_isnt [GET => '/'], 404, "response for GET / is not a 404";
=head2 response_content_is([$method, $path], $expected, $test_name)
Asserts that the response content is equal to the C<$expected> string.
response_content_is [GET => '/'], "Hello, World",
"got expected response content for GET /";
=head2 response_content_isnt([$method, $path], $not_expected, $test_name)
Asserts that the response content is not equal to the C<$not_expected> string.
response_content_isnt [GET => '/'], "Hello, World",
"got expected response content for GET /";
=head2 response_content_like([$method, $path], $regexp, $test_name)
Asserts that the response content for the given request matches the regexp
given.
response_content_like [GET => '/'], qr/Hello, World/,
"response content looks good for GET /";
=head2 response_content_unlike([$method, $path], $regexp, $test_name)
Asserts that the response content for the given request does not match the regexp
given.
response_content_unlike [GET => '/'], qr/Page not found/,
"response content looks good for GET /";
=head2 response_content_is_deeply([$method, $path], $expected_struct, $test_name)
Similar to response_content_is(), except that if response content and
$expected_struct are references, it does a deep comparison walking each data
structure to see if they are equivalent.
If the two structures are different, it will display the place where they start
differing.
response_content_is_deeply [GET => '/complex_struct'],
{ foo => 42, bar => 24},
"got expected response structure for GET /complex_struct";
=head2 response_is_file ($request, $test_name);
=head2 response_headers_are_deeply([$method, $path], $expected, $test_name)
Asserts that the response headers data structure equals the one given.
response_headers_are_deeply [GET => '/'], [ 'X-Powered-By' => 'Dancer2 1.150' ];
=head2 response_headers_include([$method, $path], $expected, $test_name)
Asserts that the response headers data structure includes some of the defined ones.
response_headers_include [GET => '/'], [ 'Content-Type' => 'text/plain' ];
=head2 route_pod_coverage()
Returns a structure describing pod coverage in your apps
for one app like this:
package t::lib::TestPod;
use Dancer2;
=head1 NAME
TestPod
=head2 ROUTES
=over
=cut
=item get "/in_testpod"
testpod
=cut
get '/in_testpod' => sub {
return 'get in_testpod';
};
get '/hello' => sub {
return "hello world";
};
=item post '/in_testpod/*'
post in_testpod
=cut
post '/in_testpod/*' => sub {
return 'post in_testpod';
};
=back
=head2 SPECIALS
=head3 PUBLIC
=over
=item get "/me:id"
=cut
get "/me:id" => sub {
return "ME";
};
=back
=head3 PRIVAT
=over
=item post "/me:id"
post /me:id
=cut
post "/me:id" => sub {
return "ME";
};
=back
=cut
1;
route_pod_coverage;
would return something like:
{
't::lib::TestPod' => {
'has_pod' => 1,
'routes' => [
"post /in_testpod/*",
"post /me:id",
"get /in_testpod",
"get /hello",
"get /me:id"
],
'undocumented_routes' => [
"get /hello"
]
}
}
=head2 is_pod_covered('is pod covered')
Asserts that your apps have pods for all routes
is_pod_covered 'is pod covered'
to avoid test failures, you should document all your routes with one of the following:
head1, head2,head3,head4, item.
ex:
=item get '/login'
route to login
=cut
if you use:
any '/myaction' => sub {
# code
}
or
any ['get', 'post'] => '/myaction' => sub {
# code
};
you need to create pods for each one of the routes created there.
=head2 import
When Dancer2::Test is imported, it should be passed all the
applications that are supposed to be tested.
If none passed, then the caller is supposed to be the sole application
to test.
# t/sometest.t
use t::lib::Foo;
use t::lib::Bar;
use Dancer2::Test apps => ['t::lib::Foo', 't::lib::Bar'];
=head1 AUTHOR
Dancer Core Developers
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2015 by Alexis Sukrieh.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
| 28.376931 | 117 | 0.582166 |
ed18fd153bf72b6315a55af38c7ad4ac9e8d6b11 | 305 | pl | Perl | 09_regex/simple2.pl | kberov/PerlProgrammingCourse | b69e87caf1f8ebfab645880b17b1b386425a58fe | [
"CC-BY-3.0"
] | 12 | 2015-01-26T16:14:19.000Z | 2021-05-04T09:06:40.000Z | 09_regex/simple2.pl | kberov/PerlProgrammingCourse | b69e87caf1f8ebfab645880b17b1b386425a58fe | [
"CC-BY-3.0"
] | null | null | null | 09_regex/simple2.pl | kberov/PerlProgrammingCourse | b69e87caf1f8ebfab645880b17b1b386425a58fe | [
"CC-BY-3.0"
] | 3 | 2015-02-04T10:56:29.000Z | 2020-02-06T04:57:04.000Z | use strict; use warnings;
my $string ='stringify this world of
words and anything';
my $word = 'string'; my $animal = 'dog';
print "found '$word'\n" if $string =~ /$word/;
print "it is not about ${animal}s\n"
if $string !~ /$animal/;
for('dog','string','dog'){
print "$word\n" if /$word/
} | 25.416667 | 46 | 0.603279 |
73fb1456be94c7ac4905976b76ddb7018b0046b8 | 1,155 | al | Perl | benchmark/benchmarks/FASP-benchmarks/data/imase-itoh/imaseitoh-0001-3-100-296.al | krzysg/FaspHeuristic | 1929c40e3fbc49e68b04acfc5522539a18758031 | [
"MIT"
] | null | null | null | benchmark/benchmarks/FASP-benchmarks/data/imase-itoh/imaseitoh-0001-3-100-296.al | krzysg/FaspHeuristic | 1929c40e3fbc49e68b04acfc5522539a18758031 | [
"MIT"
] | null | null | null | benchmark/benchmarks/FASP-benchmarks/data/imase-itoh/imaseitoh-0001-3-100-296.al | krzysg/FaspHeuristic | 1929c40e3fbc49e68b04acfc5522539a18758031 | [
"MIT"
] | null | null | null | 1 34 67
2 1 34 68
3 1 35 68
4 2 35 68
5 2 35 69
6 2 36 69
7 3 36 69
8 3 36 70
9 3 37 70
10 4 37 70
11 4 37 71
12 4 38 71
13 5 38 71
14 5 38 72
15 5 39 72
16 6 39 72
17 6 39 73
18 6 40 73
19 7 40 73
20 7 40 74
21 7 41 74
22 8 41 74
23 8 41 75
24 8 42 75
25 9 42 75
26 9 42 76
27 9 43 76
28 10 43 76
29 10 43 77
30 10 44 77
31 11 44 77
32 11 44 78
33 11 45 78
34 12 45 78
35 12 45 79
36 12 46 79
37 13 46 79
38 13 46 80
39 13 47 80
40 14 47 80
41 14 47 81
42 14 48 81
43 15 48 81
44 15 48 82
45 15 49 82
46 16 49 82
47 16 49 83
48 16 50 83
49 17 50 83
50 17 84
51 17 84
52 18 51 84
53 18 51 85
54 18 52 85
55 19 52 85
56 19 52 86
57 19 53 86
58 20 53 86
59 20 53 87
60 20 54 87
61 21 54 87
62 21 54 88
63 21 55 88
64 22 55 88
65 22 55 89
66 22 56 89
67 23 56 89
68 23 56 90
69 23 57 90
70 24 57 90
71 24 57 91
72 24 58 91
73 25 58 91
74 25 58 92
75 25 59 92
76 26 59 92
77 26 59 93
78 26 60 93
79 27 60 93
80 27 60 94
81 27 61 94
82 28 61 94
83 28 61 95
84 28 62 95
85 29 62 95
86 29 62 96
87 29 63 96
88 30 63 96
89 30 63 97
90 30 64 97
91 31 64 97
92 31 64 98
93 31 65 98
94 32 65 98
95 32 65 99
96 32 66 99
97 33 66 99
98 33 66 100
99 33 67 100
100 34 67 | 11.55 | 12 | 0.658009 |
edc84976b944b3262d5c35d361640af34a0772d9 | 61 | t | Perl | tests/harness/basic/skip-all-late.t | winspool/c-tap-harness | cc7803f9d9de89cb625a78435fe31b481c03c227 | [
"Unlicense"
] | 22 | 2015-08-14T05:49:47.000Z | 2022-03-07T06:07:08.000Z | tests/harness/basic/skip-all-late.t | winspool/c-tap-harness | cc7803f9d9de89cb625a78435fe31b481c03c227 | [
"Unlicense"
] | 8 | 2015-08-03T14:46:33.000Z | 2022-02-06T20:19:30.000Z | tests/harness/basic/skip-all-late.t | winspool/c-tap-harness | cc7803f9d9de89cb625a78435fe31b481c03c227 | [
"Unlicense"
] | 10 | 2015-03-02T16:35:17.000Z | 2022-03-07T06:07:11.000Z | #!/bin/sh
echo ok 1
echo ok 2
echo "1..0 # Skip some reason"
| 12.2 | 30 | 0.639344 |
ed360b2e4e47589f99eb62a5663bbafe74ce97ec | 843 | pl | Perl | www/CiaoDE/ciao/contrib/tester/test/tester_test2.pl | leuschel/ecce | f7f834bd219759cd7e8b3709801ffe26082c766d | [
"Apache-2.0"
] | 10 | 2015-10-16T08:23:29.000Z | 2020-08-10T18:17:26.000Z | www/CiaoDE/ciao/contrib/tester/test/tester_test2.pl | leuschel/ecce | f7f834bd219759cd7e8b3709801ffe26082c766d | [
"Apache-2.0"
] | null | null | null | www/CiaoDE/ciao/contrib/tester/test/tester_test2.pl | leuschel/ecce | f7f834bd219759cd7e8b3709801ffe26082c766d | [
"Apache-2.0"
] | 3 | 2015-10-18T11:11:44.000Z | 2019-02-13T14:18:49.000Z | :- module( tester_test2 , _ , _ ).
:- use_module( '../tester' ).
%:- use_module( library(tester) ).
:- use_module( library(lists) ).
:- use_module( library(write) ).
init_func :-
write( 'Starting the test\n' ).
tester_func( (X,X,_) ) :-
write( 'The argument is correct ' ),
write( X ) , nl.
checker_func( (_,X,X) ) :-
write( 'check is fine\n\n' ).
end_func :-
write( 'Test ended\n' ).
main :-
L = [ (1,1,1), % CORRECT
(2,2,1), % Test CORRECT , CHECK FALSE
(1,2,2) % Test FALSE
],
run_tester(
'test.log',
'result.log',
init_func ,
tester_func ,
L,
checker_func,
L,
end_func,
Res,
slider( 'Tester2: ' )
),
length( L , LL ),
Op is (Res / LL) * 100,
message( note , [ 'Analysis result: ' , Op , '%' ] ).
| 18.326087 | 55 | 0.497034 |
73fafa9ce32d3e79be4065d09d89aecec3569336 | 454 | t | Perl | t/30_Logger_Async/80_deprecation_methods.t | garykrige/elasticsearch-perl | 11932ea7a72361e77e9ee921114283a3a3e13e63 | [
"Apache-2.0"
] | 1 | 2022-03-14T10:44:11.000Z | 2022-03-14T10:44:11.000Z | t/30_Logger_Async/80_deprecation_methods.t | garykrige/elasticsearch-perl | 11932ea7a72361e77e9ee921114283a3a3e13e63 | [
"Apache-2.0"
] | null | null | null | t/30_Logger_Async/80_deprecation_methods.t | garykrige/elasticsearch-perl | 11932ea7a72361e77e9ee921114283a3a3e13e63 | [
"Apache-2.0"
] | null | null | null | use Test::More;
use Test::Exception;
use Search::Elasticsearch;
do './t/lib/LogCallback.pl' or die( $@ || $! );
isa_ok my $l = Search::Elasticsearch->new->logger,
'Search::Elasticsearch::Logger::LogAny',
'Logger';
( $method, $format ) = ();
ok $l->deprecation( "foo", { foo => 1 } ), "deprecation";
is $method, "warning", "deprecation - method";
is $format, "[DEPRECATION] foo - In request: {foo => 1}", "deprecation - format";
done_testing;
| 26.705882 | 81 | 0.632159 |
edbe544f3a539c6082aa05c4e01707057d3ccb22 | 1,460 | pl | Perl | mgcmd/awe_blat_rna.pl | mb1069/pipeline | c947b5879c61fad289771e4dce671fa5165dae48 | [
"BSD-2-Clause"
] | 19 | 2015-04-19T09:26:40.000Z | 2021-05-31T09:21:34.000Z | mgcmd/awe_blat_rna.pl | mb1069/pipeline | c947b5879c61fad289771e4dce671fa5165dae48 | [
"BSD-2-Clause"
] | 8 | 2015-05-11T21:09:37.000Z | 2019-08-23T16:25:36.000Z | mgcmd/awe_blat_rna.pl | mb1069/pipeline | c947b5879c61fad289771e4dce671fa5165dae48 | [
"BSD-2-Clause"
] | 14 | 2015-05-04T00:40:45.000Z | 2021-02-15T14:24:56.000Z | #!/usr/bin/env perl
use strict;
use warnings;
no warnings('once');
use PipelineAWE;
use Getopt::Long;
umask 000;
# options
my $fasta = "";
my $output = "";
my $rna_nr = "md5rna";
my $assembled = 0;
my $help = 0;
my $options = GetOptions (
"input=s" => \$fasta,
"output:s" => \$output,
"rna_nr=s" => \$rna_nr,
"assembled=i" => \$assembled,
"help!" => \$help
);
if ($help){
print get_usage();
exit 0;
}elsif (length($fasta)==0){
PipelineAWE::logger('error', "input file was not specified");
exit 1;
}elsif (length($output)==0){
PipelineAWE::logger('error', "output file was not specified");
exit 1;
}elsif (! -e $fasta){
PipelineAWE::logger('error', "input sequence file [$fasta] does not exist");
exit 1;
}
my $rna_nr_path = undef ;
if (-s $rna_nr) {
$rna_nr_path = $rna_nr;
}
else{
my $refdb_dir = ".";
if ($ENV{'REFDBPATH'}) {
$refdb_dir = $ENV{'REFDBPATH'};
}
$rna_nr_path = $refdb_dir."/".$rna_nr;
}
unless (-s $rna_nr_path) {
PipelineAWE::logger('error', "rna_nr not exist: $rna_nr_path");
exit 1;
}
my $opts = "";
if ($assembled == 0) {
$opts = "-fastMap ";
}
PipelineAWE::run_cmd("blat -out=blast8 -t=dna -q=dna $opts$rna_nr_path $fasta stdout | bleachsims -s - -o $output -r 0", 1);
exit 0;
sub get_usage {
return "USAGE: mgrast_blat_rna.pl -input=<input fasta> -output=<output sims> [-rna_nr=<rna nr file, default: md5rna>] \n";
}
| 21.791045 | 126 | 0.592466 |
73d204e1f761af443c9d10fba88025bfd1121453 | 217 | t | Perl | t/pod.t | MatBarba/vb-rnaseq | 9dcbd45c05d1eb3eb72ac410f000890ded51f89f | [
"Apache-2.0"
] | null | null | null | t/pod.t | MatBarba/vb-rnaseq | 9dcbd45c05d1eb3eb72ac410f000890ded51f89f | [
"Apache-2.0"
] | null | null | null | t/pod.t | MatBarba/vb-rnaseq | 9dcbd45c05d1eb3eb72ac410f000890ded51f89f | [
"Apache-2.0"
] | null | null | null | #!perl -T
use Test::More skip_all => "Dev test";
use Test::More;
eval "use Test::Pod 1.14";
plan skip_all => "Test::Pod 1.14 required for testing POD" if $@;
my @pods = all_pod_files('lib');
all_pod_files_ok(@pods);
| 24.111111 | 65 | 0.672811 |
edcf3ec37e0ddb715ac9829d90509884dc6c1efe | 7,485 | t | Perl | t/VRTrack/non_core_classes.t | sanger-pathogens/vr-codebase | a85c4e29938cd13b36fa0a1bde1db0abd7201912 | [
"BSD-Source-Code"
] | 7 | 2015-11-20T11:38:02.000Z | 2020-11-02T18:08:18.000Z | t/VRTrack/non_core_classes.t | sanger-pathogens/vr-codebase | a85c4e29938cd13b36fa0a1bde1db0abd7201912 | [
"BSD-Source-Code"
] | 11 | 2015-05-12T11:09:51.000Z | 2022-03-22T11:11:20.000Z | t/VRTrack/non_core_classes.t | sanger-pathogens/vr-codebase | a85c4e29938cd13b36fa0a1bde1db0abd7201912 | [
"BSD-Source-Code"
] | 14 | 2015-06-26T09:28:41.000Z | 2021-07-23T11:25:28.000Z | #!/usr/bin/perl -w
use strict;
use warnings;
BEGIN {
use Test::Most;
eval {
require VRTrack::Testconfig;
};
if ($@) {
plan skip_all => "Skipping all tests because VRTrack tests have not been configured";
}
else {
plan tests => 64;
}
use_ok('VRTrack::VRTrack');
use_ok('VRTrack::Image');
use_ok('VRTrack::AutoQC');
use_ok('VRTrack::Individual');
use_ok('VRTrack::Lane');
use_ok('VRTrack::Mapper');
use_ok('VRTrack::Study');
use_ok('VRTrack::Species');
}
my $connection_details = { database => VRTrack::Testconfig->config('test_db'),
host => VRTrack::Testconfig->config('host'),
port => VRTrack::Testconfig->config('port'),
user => VRTrack::Testconfig->config('user'),
password => VRTrack::Testconfig->config('password'),
};
# access the db as normal with new()
ok my $vrtrack = VRTrack::VRTrack->new($connection_details), 'new() returned something';
isa_ok $vrtrack, 'VRTrack::VRTrack';
# allocation
# TODO
# image
my $image_name = 'image_test_orig';
my $imagedata = 'test_binaryimagedata';
ok my $image = VRTrack::Image->create($vrtrack, $image_name, $imagedata), 'image create worked';
my $image_id = $image->id;
$image = VRTrack::Image->new($vrtrack, $image_id);
is $image->id, $image_id, 'Image new returned the image we made before';
is $image->image(),$imagedata, 'image data stored correctly';
$image_name = 'image_test_changed';
is $image->name($image_name), $image_name, 'image name could be get/set';
is $image->caption('foo'), 'foo', 'image caption could be get/set';
ok $image->update, 'update worked on image';
$image = VRTrack::Image->new($vrtrack, $image_id);
is_deeply [$image->id, $image->name, $image->image], [$image_id, $image_name, $imagedata], 'after update, the things really were set';
# AutoQC
my $reason='The lane failed the NPG QC check, so auto-fail';
ok my $autoqc = VRTrack::AutoQC->create($vrtrack, 'NPG QC status', 0, $reason), 'autoqc create worked';
my $autoqc_id = $autoqc->id;
$autoqc = VRTrack::AutoQC->new($vrtrack, $autoqc_id);
is $autoqc->id, $autoqc_id, 'AutoQC new returned the autoqc we made before';
is $autoqc->reason(),$reason, 'autoqc reason stored correctly';
# test autoqc getters/setters
my $qc_test = 'autoqc_qc_test_name_changed';
is $autoqc->test($qc_test), $qc_test, 'autoqc test name could be get/set';
my $qc_reason= 'modified test result reason';
is $autoqc->reason($qc_reason), $qc_reason, 'autoqc reason name could be get/set';
my $qc_result= 0;
is $autoqc->result($qc_result), $qc_result, 'autoqc result could be updated';
ok $autoqc->update, 'update worked on autoqc';
# Add autoqcs to mapping stats
my $mapstats = "VRTrack::Mapstats"->create($vrtrack);
ok $autoqc = $mapstats->add_autoqc('NPG QC status',1,'The lane failed the NPG QC check'),'added autoqc to mapping stats';
my @autoqc_statuses = @{ $mapstats->autoqcs() };
is scalar @autoqc_statuses,1, 'got autoqc array ref back from db';
# update autoqc test result
ok $autoqc = $mapstats->add_autoqc('NPG QC status',0,'The lane passed the NPG QC check'),'re-added (updated) an autoqc test';
is $autoqc->result(), 0, 'autoqc result was updated';
# individual
# setting species_id and population id for the first individual
my $ind_name = "test ind";
my $ind_hname = "test_ind";
ok my $individual = VRTrack::Individual->create($vrtrack, $ind_name), 'created individual';
my $ind_id = $individual->id;
$individual = VRTrack::Individual->new($vrtrack, $ind_id);
is $individual->id, $ind_id, 'Individual new returned the individual we made before';
is $individual->name, $ind_name, 'Individual name was stored correctly';
is $individual->hierarchy_name, $ind_hname, 'Individual hierarchy name was generated correctly';
is $individual->sex(), 'unknown', 'Individual sex defaults to unknown if not set';
$ind_name = 'individual_test|changed';
is $individual->name($ind_name), $ind_name, 'Individual name could be get/set';
is $individual->sex('M'), 'M', 'Individual sex could be get/set to M';
is $individual->sex('foobar'), 'unknown', 'Individual sex is set to unknown for non M/F';
is $individual->sex('F'), 'F', 'Individual sex could be get/set to F';
ok $individual->update, 'update worked on Individual';
$individual = VRTrack::Individual->new_by_name($vrtrack, $ind_name);
is_deeply [$individual->id, $individual->name, $individual->sex], [1, $ind_name, 'F'], 'Individual new_by_name worked';
my $species_name = 'genus species subspecies';
is $individual->species($species_name), undef, 'species() returned undef when setting a non-existant species';
is $individual->species_id, undef, 'species_id starts undefined';
ok my $spp = $individual->add_species($species_name), 'add_species made a new species';
ok my $spp_id = $spp->id, 'species id has an id';
is $individual->species_id, $spp_id, 'species_id was updated';
my $pop_name = 'population_test';
is $individual->population($pop_name), undef, 'population() returned undef when setting a non-existant population';
is $individual->population_id, undef, 'population_id starts undefined';
ok my $pop = $individual->add_population($pop_name), 'add_population made a new population';
ok my $pop_id = $pop->id, 'population has an id';
my $values = VRTrack::Individual->_all_values_by_field($vrtrack, 'name', 'individual_id');
is($values->[0], $ind_name, " _all_values_by_field should return first individual name value correctly");
is $individual->population_id, $pop_id, 'population_id was updated';
$individual->update();
# mapper
my $mapper_name = 'test_mapper';
ok my $mapper = VRTrack::Mapper->create($vrtrack, $mapper_name, 1.1), 'Mapper create worked';
my $mapper_id = $mapper->id;
$mapper = VRTrack::Mapper->new($vrtrack, $mapper_id);
is $mapper->id, $mapper_id, 'Mapper new returned the first Mapper we made before';
is $mapper->name, $mapper_name, 'Mapper name set correctly';
is $mapper->version, 1.1, 'Mapper version set correctly';
$mapper_name = 'mapper_test_changed';
is $mapper->name($mapper_name), $mapper_name, 'Mapper name could be get/set';
ok $mapper->update, 'update worked on Mapper';
$mapper = VRTrack::Mapper->new_by_name_version($vrtrack, $mapper_name, 1.1);
is_deeply [$mapper->id, $mapper->name, $mapper->version], [$mapper_id, $mapper_name, 1.1], 'Mapper new_by_name_version worked';
# study
my $study_acc = 'test_study';
ok my $study = VRTrack::Study->create($vrtrack, $study_acc), 'study create worked';
my $study_id = $study->id;
$study = VRTrack::Study->new_by_acc($vrtrack, $study_acc);
is_deeply [$study->id, $study->acc], [$study_id, $study_acc], 'Study new_by_acc worked';
$study_acc .= '2';
is $study->acc($study_acc), $study_acc, 'study acc could be get/set';
ok $study->update, 'update worked on study';
$study = VRTrack::Study->new_by_acc($vrtrack, $study_acc);
is_deeply [$study->id, $study->acc], [$study_id, $study_acc], 'Study new_by_acc worked again';
# species
my $species = VRTrack::Species->create($vrtrack,"organism");
is $species->taxon_id(),0, 'Created a species entry with taxon id 0 as expected';
my $other_species = VRTrack::Species->create($vrtrack,"organism_2",456);
is $other_species->taxon_id(),456, 'Created a species entry with taxon id 456 as expected';
# cleanup
my $dbh = $vrtrack->{_dbh};
foreach ($dbh->tables()){
next if /`latest_/;
next if /schema_version/;
$dbh->do("TRUNCATE TABLE $_");
}
exit;
| 47.075472 | 134 | 0.699399 |
ed9332a65cc582d181481643df5171dae29171ca | 473 | pl | Perl | ndk/prebuilt/linux-x86_64/lib/perl5/5.16.2/unicore/lib/Scx/Deva.pl | efortuna/AndroidSDKClone | 240e73b763c159af6bbcd111f2705b549e85295a | [
"Apache-2.0"
] | 1 | 2019-07-10T15:21:02.000Z | 2019-07-10T15:21:02.000Z | ndk/prebuilt/linux-x86_64/lib/perl5/5.16.2/unicore/lib/Scx/Deva.pl | efortuna/AndroidSDKClone | 240e73b763c159af6bbcd111f2705b549e85295a | [
"Apache-2.0"
] | null | null | null | ndk/prebuilt/linux-x86_64/lib/perl5/5.16.2/unicore/lib/Scx/Deva.pl | efortuna/AndroidSDKClone | 240e73b763c159af6bbcd111f2705b549e85295a | [
"Apache-2.0"
] | 1 | 2019-02-25T11:55:44.000Z | 2019-02-25T11:55:44.000Z | # !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
# This file is machine-generated by lib/unicore/mktables from the Unicode
# database, Version 6.1.0. Any changes made here will be lost!
# !!!!!!! INTERNAL PERL USE ONLY !!!!!!!
# This file is for internal use by core Perl only. The format and even the
# name or existence of this file are subject to change without notice. Don't
# use it directly.
return <<'END';
0900 0950
0953 0977
0979 097F
A830 A839
A8E0 A8FB
END
| 26.277778 | 77 | 0.684989 |
edbd55b4289c94b91db4df7d7f110ee9ea24f49e | 24,768 | pm | Perl | lib/HTTP/Headers.pm | galenhuntington/HTTP-Message | 1d6860725abdaa801af23da1af6ed07db0b9d1b8 | [
"Artistic-1.0"
] | 11 | 2017-09-22T09:03:00.000Z | 2022-01-07T11:41:13.000Z | lib/HTTP/Headers.pm | topaz/HTTP-Message | b8a00e5b149d4a2396c88f3b00fd2f6e1386407f | [
"Artistic-1.0"
] | 141 | 2016-06-25T02:37:34.000Z | 2021-12-23T19:45:41.000Z | lib/HTTP/Headers.pm | topaz/HTTP-Message | b8a00e5b149d4a2396c88f3b00fd2f6e1386407f | [
"Artistic-1.0"
] | 37 | 2016-08-15T10:20:37.000Z | 2021-12-15T20:54:42.000Z | package HTTP::Headers;
use strict;
use warnings;
our $VERSION = '6.34';
use Carp ();
# The $TRANSLATE_UNDERSCORE variable controls whether '_' can be used
# as a replacement for '-' in header field names.
our $TRANSLATE_UNDERSCORE = 1 unless defined $TRANSLATE_UNDERSCORE;
# "Good Practice" order of HTTP message headers:
# - General-Headers
# - Request-Headers
# - Response-Headers
# - Entity-Headers
my @general_headers = qw(
Cache-Control Connection Date Pragma Trailer Transfer-Encoding Upgrade
Via Warning
);
my @request_headers = qw(
Accept Accept-Charset Accept-Encoding Accept-Language
Authorization Expect From Host
If-Match If-Modified-Since If-None-Match If-Range If-Unmodified-Since
Max-Forwards Proxy-Authorization Range Referer TE User-Agent
);
my @response_headers = qw(
Accept-Ranges Age ETag Location Proxy-Authenticate Retry-After Server
Vary WWW-Authenticate
);
my @entity_headers = qw(
Allow Content-Encoding Content-Language Content-Length Content-Location
Content-MD5 Content-Range Content-Type Expires Last-Modified
);
my %entity_header = map { lc($_) => 1 } @entity_headers;
my @header_order = (
@general_headers,
@request_headers,
@response_headers,
@entity_headers,
);
# Make alternative representations of @header_order. This is used
# for sorting and case matching.
my %header_order;
my %standard_case;
{
my $i = 0;
for (@header_order) {
my $lc = lc $_;
$header_order{$lc} = ++$i;
$standard_case{$lc} = $_;
}
}
sub new
{
my($class) = shift;
my $self = bless {}, $class;
$self->header(@_) if @_; # set up initial headers
$self;
}
sub header
{
my $self = shift;
Carp::croak('Usage: $h->header($field, ...)') unless @_;
my(@old);
my %seen;
while (@_) {
my $field = shift;
my $op = @_ ? ($seen{lc($field)}++ ? 'PUSH' : 'SET') : 'GET';
@old = $self->_header($field, shift, $op);
}
return @old if wantarray;
return $old[0] if @old <= 1;
join(", ", @old);
}
sub clear
{
my $self = shift;
%$self = ();
}
sub push_header
{
my $self = shift;
return $self->_header(@_, 'PUSH_H') if @_ == 2;
while (@_) {
$self->_header(splice(@_, 0, 2), 'PUSH_H');
}
}
sub init_header
{
Carp::croak('Usage: $h->init_header($field, $val)') if @_ != 3;
shift->_header(@_, 'INIT');
}
sub remove_header
{
my($self, @fields) = @_;
my $field;
my @values;
foreach $field (@fields) {
$field =~ tr/_/-/ if $field !~ /^:/ && $TRANSLATE_UNDERSCORE;
my $v = delete $self->{lc $field};
push(@values, ref($v) eq 'ARRAY' ? @$v : $v) if defined $v;
}
return @values;
}
sub remove_content_headers
{
my $self = shift;
unless (defined(wantarray)) {
# fast branch that does not create return object
delete @$self{grep $entity_header{$_} || /^content-/, keys %$self};
return;
}
my $c = ref($self)->new;
for my $f (grep $entity_header{$_} || /^content-/, keys %$self) {
$c->{$f} = delete $self->{$f};
}
if (exists $self->{'::std_case'}) {
$c->{'::std_case'} = $self->{'::std_case'};
}
$c;
}
sub _header
{
my($self, $field, $val, $op) = @_;
Carp::croak("Illegal field name '$field'")
if rindex($field, ':') > 1 || !length($field);
unless ($field =~ /^:/) {
$field =~ tr/_/-/ if $TRANSLATE_UNDERSCORE;
my $old = $field;
$field = lc $field;
unless($standard_case{$field} || $self->{'::std_case'}{$field}) {
# generate a %std_case entry for this field
$old =~ s/\b(\w)/\u$1/g;
$self->{'::std_case'}{$field} = $old;
}
}
$op ||= defined($val) ? 'SET' : 'GET';
if ($op eq 'PUSH_H') {
# Like PUSH but where we don't care about the return value
if (exists $self->{$field}) {
my $h = $self->{$field};
if (ref($h) eq 'ARRAY') {
push(@$h, ref($val) eq "ARRAY" ? @$val : $val);
}
else {
$self->{$field} = [$h, ref($val) eq "ARRAY" ? @$val : $val]
}
return;
}
$self->{$field} = $val;
return;
}
my $h = $self->{$field};
my @old = ref($h) eq 'ARRAY' ? @$h : (defined($h) ? ($h) : ());
unless ($op eq 'GET' || ($op eq 'INIT' && @old)) {
if (defined($val)) {
my @new = ($op eq 'PUSH') ? @old : ();
if (ref($val) ne 'ARRAY') {
push(@new, $val);
}
else {
push(@new, @$val);
}
$self->{$field} = @new > 1 ? \@new : $new[0];
}
elsif ($op ne 'PUSH') {
delete $self->{$field};
}
}
@old;
}
sub _sorted_field_names
{
my $self = shift;
return [ sort {
($header_order{$a} || 999) <=> ($header_order{$b} || 999) ||
$a cmp $b
} grep !/^::/, keys %$self ];
}
sub header_field_names {
my $self = shift;
return map $standard_case{$_} || $self->{'::std_case'}{$_} || $_, @{ $self->_sorted_field_names },
if wantarray;
return grep !/^::/, keys %$self;
}
sub scan
{
my($self, $sub) = @_;
my $key;
for $key (@{ $self->_sorted_field_names }) {
my $vals = $self->{$key};
if (ref($vals) eq 'ARRAY') {
my $val;
for $val (@$vals) {
$sub->($standard_case{$key} || $self->{'::std_case'}{$key} || $key, $val);
}
}
else {
$sub->($standard_case{$key} || $self->{'::std_case'}{$key} || $key, $vals);
}
}
}
sub flatten {
my($self)=@_;
(
map {
my $k = $_;
map {
( $k => $_ )
} $self->header($_);
} $self->header_field_names
);
}
sub as_string
{
my($self, $endl) = @_;
$endl = "\n" unless defined $endl;
my @result = ();
for my $key (@{ $self->_sorted_field_names }) {
next if index($key, '_') == 0;
my $vals = $self->{$key};
if ( ref($vals) eq 'ARRAY' ) {
for my $val (@$vals) {
$val = '' if not defined $val;
my $field = $standard_case{$key} || $self->{'::std_case'}{$key} || $key;
$field =~ s/^://;
if ( index($val, "\n") >= 0 ) {
$val = _process_newline($val, $endl);
}
push @result, $field . ': ' . $val;
}
}
else {
$vals = '' if not defined $vals;
my $field = $standard_case{$key} || $self->{'::std_case'}{$key} || $key;
$field =~ s/^://;
if ( index($vals, "\n") >= 0 ) {
$vals = _process_newline($vals, $endl);
}
push @result, $field . ': ' . $vals;
}
}
join($endl, @result, '');
}
sub _process_newline {
local $_ = shift;
my $endl = shift;
# must handle header values with embedded newlines with care
s/\s+$//; # trailing newlines and space must go
s/\n(\x0d?\n)+/\n/g; # no empty lines
s/\n([^\040\t])/\n $1/g; # initial space for continuation
s/\n/$endl/g; # substitute with requested line ending
$_;
}
if (eval { require Clone; 1 }) {
*clone = \&Clone::clone;
} else {
*clone = sub {
my $self = shift;
my $clone = HTTP::Headers->new;
$self->scan(sub { $clone->push_header(@_);} );
$clone;
};
}
sub _date_header
{
require HTTP::Date;
my($self, $header, $time) = @_;
my($old) = $self->_header($header);
if (defined $time) {
$self->_header($header, HTTP::Date::time2str($time));
}
$old =~ s/;.*// if defined($old);
HTTP::Date::str2time($old);
}
sub date { shift->_date_header('Date', @_); }
sub expires { shift->_date_header('Expires', @_); }
sub if_modified_since { shift->_date_header('If-Modified-Since', @_); }
sub if_unmodified_since { shift->_date_header('If-Unmodified-Since', @_); }
sub last_modified { shift->_date_header('Last-Modified', @_); }
# This is used as a private LWP extension. The Client-Date header is
# added as a timestamp to a response when it has been received.
sub client_date { shift->_date_header('Client-Date', @_); }
# The retry_after field is dual format (can also be a expressed as
# number of seconds from now), so we don't provide an easy way to
# access it until we have know how both these interfaces can be
# addressed. One possibility is to return a negative value for
# relative seconds and a positive value for epoch based time values.
#sub retry_after { shift->_date_header('Retry-After', @_); }
sub content_type {
my $self = shift;
my $ct = $self->{'content-type'};
$self->{'content-type'} = shift if @_;
$ct = $ct->[0] if ref($ct) eq 'ARRAY';
return '' unless defined($ct) && length($ct);
my @ct = split(/;\s*/, $ct, 2);
for ($ct[0]) {
s/\s+//g;
$_ = lc($_);
}
wantarray ? @ct : $ct[0];
}
sub content_type_charset {
my $self = shift;
require HTTP::Headers::Util;
my $h = $self->{'content-type'};
$h = $h->[0] if ref($h);
$h = "" unless defined $h;
my @v = HTTP::Headers::Util::split_header_words($h);
if (@v) {
my($ct, undef, %ct_param) = @{$v[0]};
my $charset = $ct_param{charset};
if ($ct) {
$ct = lc($ct);
$ct =~ s/\s+//;
}
if ($charset) {
$charset = uc($charset);
$charset =~ s/^\s+//; $charset =~ s/\s+\z//;
undef($charset) if $charset eq "";
}
return $ct, $charset if wantarray;
return $charset;
}
return undef, undef if wantarray;
return undef;
}
sub content_is_text {
my $self = shift;
return $self->content_type =~ m,^text/,;
}
sub content_is_html {
my $self = shift;
return $self->content_type eq 'text/html' || $self->content_is_xhtml;
}
sub content_is_xhtml {
my $ct = shift->content_type;
return $ct eq "application/xhtml+xml" ||
$ct eq "application/vnd.wap.xhtml+xml";
}
sub content_is_xml {
my $ct = shift->content_type;
return 1 if $ct eq "text/xml";
return 1 if $ct eq "application/xml";
return 1 if $ct =~ /\+xml$/;
return 0;
}
sub referer {
my $self = shift;
if (@_ && $_[0] =~ /#/) {
# Strip fragment per RFC 2616, section 14.36.
my $uri = shift;
if (ref($uri)) {
$uri = $uri->clone;
$uri->fragment(undef);
}
else {
$uri =~ s/\#.*//;
}
unshift @_, $uri;
}
($self->_header('Referer', @_))[0];
}
*referrer = \&referer; # on tchrist's request
sub title { (shift->_header('Title', @_))[0] }
sub content_encoding { (shift->_header('Content-Encoding', @_))[0] }
sub content_language { (shift->_header('Content-Language', @_))[0] }
sub content_length { (shift->_header('Content-Length', @_))[0] }
sub user_agent { (shift->_header('User-Agent', @_))[0] }
sub server { (shift->_header('Server', @_))[0] }
sub from { (shift->_header('From', @_))[0] }
sub warning { (shift->_header('Warning', @_))[0] }
sub www_authenticate { (shift->_header('WWW-Authenticate', @_))[0] }
sub authorization { (shift->_header('Authorization', @_))[0] }
sub proxy_authenticate { (shift->_header('Proxy-Authenticate', @_))[0] }
sub proxy_authorization { (shift->_header('Proxy-Authorization', @_))[0] }
sub authorization_basic { shift->_basic_auth("Authorization", @_) }
sub proxy_authorization_basic { shift->_basic_auth("Proxy-Authorization", @_) }
sub _basic_auth {
require MIME::Base64;
my($self, $h, $user, $passwd) = @_;
my($old) = $self->_header($h);
if (defined $user) {
Carp::croak("Basic authorization user name can't contain ':'")
if $user =~ /:/;
$passwd = '' unless defined $passwd;
$self->_header($h => 'Basic ' .
MIME::Base64::encode("$user:$passwd", ''));
}
if (defined $old && $old =~ s/^\s*Basic\s+//) {
my $val = MIME::Base64::decode($old);
return $val unless wantarray;
return split(/:/, $val, 2);
}
return;
}
1;
__END__
=pod
=head1 SYNOPSIS
require HTTP::Headers;
$h = HTTP::Headers->new;
$h->header('Content-Type' => 'text/plain'); # set
$ct = $h->header('Content-Type'); # get
$h->remove_header('Content-Type'); # delete
=head1 DESCRIPTION
The C<HTTP::Headers> class encapsulates HTTP-style message headers.
The headers consist of attribute-value pairs also called fields, which
may be repeated, and which are printed in a particular order. The
field names are cases insensitive.
Instances of this class are usually created as member variables of the
C<HTTP::Request> and C<HTTP::Response> classes, internal to the
library.
The following methods are available:
=over 4
=item $h = HTTP::Headers->new
Constructs a new C<HTTP::Headers> object. You might pass some initial
attribute-value pairs as parameters to the constructor. I<E.g.>:
$h = HTTP::Headers->new(
Date => 'Thu, 03 Feb 1994 00:00:00 GMT',
Content_Type => 'text/html; version=3.2',
Content_Base => 'http://www.perl.org/');
The constructor arguments are passed to the C<header> method which is
described below.
=item $h->clone
Returns a copy of this C<HTTP::Headers> object.
=item $h->header( $field )
=item $h->header( $field => $value )
=item $h->header( $f1 => $v1, $f2 => $v2, ... )
Get or set the value of one or more header fields. The header field
name ($field) is not case sensitive. To make the life easier for perl
users who wants to avoid quoting before the => operator, you can use
'_' as a replacement for '-' in header names.
The header() method accepts multiple ($field => $value) pairs, which
means that you can update several fields with a single invocation.
The $value argument may be a plain string or a reference to an array
of strings for a multi-valued field. If the $value is provided as
C<undef> then the field is removed. If the $value is not given, then
that header field will remain unchanged. In addition to being a string,
$value may be something that stringifies.
The old value (or values) of the last of the header fields is returned.
If no such field exists C<undef> will be returned.
A multi-valued field will be returned as separate values in list
context and will be concatenated with ", " as separator in scalar
context. The HTTP spec (RFC 2616) promises that joining multiple
values in this way will not change the semantic of a header field, but
in practice there are cases like old-style Netscape cookies (see
L<HTTP::Cookies>) where "," is used as part of the syntax of a single
field value.
Examples:
$header->header(MIME_Version => '1.0',
User_Agent => 'My-Web-Client/0.01');
$header->header(Accept => "text/html, text/plain, image/*");
$header->header(Accept => [qw(text/html text/plain image/*)]);
@accepts = $header->header('Accept'); # get multiple values
$accepts = $header->header('Accept'); # get values as a single string
=item $h->push_header( $field => $value )
=item $h->push_header( $f1 => $v1, $f2 => $v2, ... )
Add a new field value for the specified header field. Previous values
for the same field are retained.
As for the header() method, the field name ($field) is not case
sensitive and '_' can be used as a replacement for '-'.
The $value argument may be a scalar or a reference to a list of
scalars.
$header->push_header(Accept => 'image/jpeg');
$header->push_header(Accept => [map "image/$_", qw(gif png tiff)]);
=item $h->init_header( $field => $value )
Set the specified header to the given value, but only if no previous
value for that field is set.
The header field name ($field) is not case sensitive and '_'
can be used as a replacement for '-'.
The $value argument may be a scalar or a reference to a list of
scalars.
=item $h->remove_header( $field, ... )
This function removes the header fields with the specified names.
The header field names ($field) are not case sensitive and '_'
can be used as a replacement for '-'.
The return value is the values of the fields removed. In scalar
context the number of fields removed is returned.
Note that if you pass in multiple field names then it is generally not
possible to tell which of the returned values belonged to which field.
=item $h->remove_content_headers
This will remove all the header fields used to describe the content of
a message. All header field names prefixed with C<Content-> fall
into this category, as well as C<Allow>, C<Expires> and
C<Last-Modified>. RFC 2616 denotes these fields as I<Entity Header
Fields>.
The return value is a new C<HTTP::Headers> object that contains the
removed headers only.
=item $h->clear
This will remove all header fields.
=item $h->header_field_names
Returns the list of distinct names for the fields present in the
header. The field names have case as suggested by HTTP spec, and the
names are returned in the recommended "Good Practice" order.
In scalar context return the number of distinct field names.
=item $h->scan( \&process_header_field )
Apply a subroutine to each header field in turn. The callback routine
is called with two parameters; the name of the field and a single
value (a string). If a header field is multi-valued, then the
routine is called once for each value. The field name passed to the
callback routine has case as suggested by HTTP spec, and the headers
will be visited in the recommended "Good Practice" order.
Any return values of the callback routine are ignored. The loop can
be broken by raising an exception (C<die>), but the caller of scan()
would have to trap the exception itself.
=item $h->flatten()
Returns the list of pairs of keys and values.
=item $h->as_string
=item $h->as_string( $eol )
Return the header fields as a formatted MIME header. Since it
internally uses the C<scan> method to build the string, the result
will use case as suggested by HTTP spec, and it will follow
recommended "Good Practice" of ordering the header fields. Long header
values are not folded.
The optional $eol parameter specifies the line ending sequence to
use. The default is "\n". Embedded "\n" characters in header field
values will be substituted with this line ending sequence.
=back
=head1 CONVENIENCE METHODS
The most frequently used headers can also be accessed through the
following convenience methods. Most of these methods can both be used to read
and to set the value of a header. The header value is set if you pass
an argument to the method. The old header value is always returned.
If the given header did not exist then C<undef> is returned.
Methods that deal with dates/times always convert their value to system
time (seconds since Jan 1, 1970) and they also expect this kind of
value when the header value is set.
=over 4
=item $h->date
This header represents the date and time at which the message was
originated. I<E.g.>:
$h->date(time); # set current date
=item $h->expires
This header gives the date and time after which the entity should be
considered stale.
=item $h->if_modified_since
=item $h->if_unmodified_since
These header fields are used to make a request conditional. If the requested
resource has (or has not) been modified since the time specified in this field,
then the server will return a C<304 Not Modified> response instead of
the document itself.
=item $h->last_modified
This header indicates the date and time at which the resource was last
modified. I<E.g.>:
# check if document is more than 1 hour old
if (my $last_mod = $h->last_modified) {
if ($last_mod < time - 60*60) {
...
}
}
=item $h->content_type
The Content-Type header field indicates the media type of the message
content. I<E.g.>:
$h->content_type('text/html');
The value returned will be converted to lower case, and potential
parameters will be chopped off and returned as a separate value if in
an array context. If there is no such header field, then the empty
string is returned. This makes it safe to do the following:
if ($h->content_type eq 'text/html') {
# we enter this place even if the real header value happens to
# be 'TEXT/HTML; version=3.0'
...
}
=item $h->content_type_charset
Returns the upper-cased charset specified in the Content-Type header. In list
context return the lower-cased bare content type followed by the upper-cased
charset. Both values will be C<undef> if not specified in the header.
=item $h->content_is_text
Returns TRUE if the Content-Type header field indicate that the
content is textual.
=item $h->content_is_html
Returns TRUE if the Content-Type header field indicate that the
content is some kind of HTML (including XHTML). This method can't be
used to set Content-Type.
=item $h->content_is_xhtml
Returns TRUE if the Content-Type header field indicate that the
content is XHTML. This method can't be used to set Content-Type.
=item $h->content_is_xml
Returns TRUE if the Content-Type header field indicate that the
content is XML. This method can't be used to set Content-Type.
=item $h->content_encoding
The Content-Encoding header field is used as a modifier to the
media type. When present, its value indicates what additional
encoding mechanism has been applied to the resource.
=item $h->content_length
A decimal number indicating the size in bytes of the message content.
=item $h->content_language
The natural language(s) of the intended audience for the message
content. The value is one or more language tags as defined by RFC
1766. Eg. "no" for some kind of Norwegian and "en-US" for English the
way it is written in the US.
=item $h->title
The title of the document. In libwww-perl this header will be
initialized automatically from the E<lt>TITLE>...E<lt>/TITLE> element
of HTML documents. I<This header is no longer part of the HTTP
standard.>
=item $h->user_agent
This header field is used in request messages and contains information
about the user agent originating the request. I<E.g.>:
$h->user_agent('Mozilla/5.0 (compatible; MSIE 7.0; Windows NT 6.0)');
=item $h->server
The server header field contains information about the software being
used by the originating server program handling the request.
=item $h->from
This header should contain an Internet e-mail address for the human
user who controls the requesting user agent. The address should be
machine-usable, as defined by RFC822. E.g.:
$h->from('King Kong <[email protected]>');
I<This header is no longer part of the HTTP standard.>
=item $h->referer
Used to specify the address (URI) of the document from which the
requested resource address was obtained.
The "Free On-line Dictionary of Computing" as this to say about the
word I<referer>:
<World-Wide Web> A misspelling of "referrer" which
somehow made it into the {HTTP} standard. A given {web
page}'s referer (sic) is the {URL} of whatever web page
contains the link that the user followed to the current
page. Most browsers pass this information as part of a
request.
(1998-10-19)
By popular demand C<referrer> exists as an alias for this method so you
can avoid this misspelling in your programs and still send the right
thing on the wire.
When setting the referrer, this method removes the fragment from the
given URI if it is present, as mandated by RFC2616. Note that
the removal does I<not> happen automatically if using the header(),
push_header() or init_header() methods to set the referrer.
=item $h->www_authenticate
This header must be included as part of a C<401 Unauthorized> response.
The field value consist of a challenge that indicates the
authentication scheme and parameters applicable to the requested URI.
=item $h->proxy_authenticate
This header must be included in a C<407 Proxy Authentication Required>
response.
=item $h->authorization
=item $h->proxy_authorization
A user agent that wishes to authenticate itself with a server or a
proxy, may do so by including these headers.
=item $h->authorization_basic
This method is used to get or set an authorization header that use the
"Basic Authentication Scheme". In array context it will return two
values; the user name and the password. In scalar context it will
return I<"uname:password"> as a single string value.
When used to set the header value, it expects two arguments. I<E.g.>:
$h->authorization_basic($uname, $password);
The method will croak if the $uname contains a colon ':'.
=item $h->proxy_authorization_basic
Same as authorization_basic() but will set the "Proxy-Authorization"
header instead.
=back
=head1 NON-CANONICALIZED FIELD NAMES
The header field name spelling is normally canonicalized including the
'_' to '-' translation. There are some application where this is not
appropriate. Prefixing field names with ':' allow you to force a
specific spelling. For example if you really want a header field name
to show up as C<foo_bar> instead of "Foo-Bar", you might set it like
this:
$h->header(":foo_bar" => 1);
These field names are returned with the ':' intact for
$h->header_field_names and the $h->scan callback, but the colons do
not show in $h->as_string.
=cut
#ABSTRACT: Class encapsulating HTTP Message headers
| 28.468966 | 102 | 0.658753 |
edb0c918f4cfbf082e6a7a4bdc4b5eeab921ab3f | 5,005 | pm | Perl | modules/Bio/EnsEMBL/Variation/Pipeline/GetCAR/GetCAR_conf.pm | diegomscoelho/ensembl-variation | ac8178e987511a0bd2357334150c4271e6698896 | [
"Apache-2.0"
] | 23 | 2015-03-12T13:38:22.000Z | 2021-11-15T10:10:14.000Z | modules/Bio/EnsEMBL/Variation/Pipeline/GetCAR/GetCAR_conf.pm | diegomscoelho/ensembl-variation | ac8178e987511a0bd2357334150c4271e6698896 | [
"Apache-2.0"
] | 674 | 2015-02-09T15:50:52.000Z | 2022-03-30T10:23:40.000Z | modules/Bio/EnsEMBL/Variation/Pipeline/GetCAR/GetCAR_conf.pm | diegomscoelho/ensembl-variation | ac8178e987511a0bd2357334150c4271e6698896 | [
"Apache-2.0"
] | 97 | 2015-02-05T15:48:14.000Z | 2022-02-08T17:45:41.000Z | =head1 LICENSE
Copyright [1999-2015] Wellcome Trust Sanger Institute and the EMBL-European Bioinformatics Institute
Copyright [2016-2021] EMBL-European Bioinformatics Institute
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=cut
=head1 CONTACT
Please email comments or questions to the public Ensembl
developers list at <http://lists.ensembl.org/mailman/listinfo/dev>.
Questions may also be sent to the Ensembl help desk at
<http://www.ensembl.org/Help/Contact>.
=cut
package Bio::EnsEMBL::Variation::Pipeline::GetCAR::GetCAR_conf;
use strict;
use warnings;
use Bio::EnsEMBL::Hive::PipeConfig::HiveGeneric_conf;
use base ('Bio::EnsEMBL::Hive::PipeConfig::EnsemblGeneric_conf');
sub default_options {
my ($self) = @_;
# The hash returned from this function is used to configure the
# pipeline, you can supply any of these options on the command
# line to override these default values.
# You shouldn't need to edit anything in this file other than
# these values, if you find you do need to then we should probably
# make it an option here, contact the variation team to discuss
# this - patches are welcome!
#
return {
%{ $self->SUPER::default_options() }, # inherit from parent
# the general options that you should change to suit your environment
hive_force_init => 1,
hive_use_param_stack => 0,
hive_use_triggers => 0,
hive_auto_rebalance_semaphores => 0, # do not attempt to rebalance semaphores periodically by default
hive_no_init => 0, # setting it to 1 will skip pipeline_create_commands (useful for topping up)
# the location of your checkout of the ensembl API
ensembl_cvs_root_dir => $ENV{'ENSEMBL_ROOT_DIR'} || $self->o('ensembl_cvs_root_dir'),
hive_root_dir => $self->o('ensembl_cvs_root_dir') . '/ensembl-hive',
debug => 0,
pipeline_name => 'car_lu',
species => 'homo_sapiens',
pipeline_dir => $self->o('pipeline_dir'),
hgvs_dir => $self->o('pipeline_dir') . '/hgvs',
car_lu_dir => $self->o('pipeline_dir') . '/car_lu',
pipeline_db => {
-host => $self->o('hive_db_host'),
-port => $self->o('hive_db_port'),
-user => $self->o('hive_db_user'),
-pass => $self->o('hive_db_password'),
-dbname => $ENV{'USER'} . '_' . $self->o('pipeline_name'),
-driver => 'mysql',
},
};
}
sub pipeline_wide_parameters {
my ($self) = @_;
return {
%{$self->SUPER::pipeline_wide_parameters}, # here we inherit anything from the base class
debug => $self->o('debug'),
pipeline_dir => $self->o('pipeline_dir'),
hgvs_dir => $self->o('hgvs_dir'),
car_lu_dir => $self->o('car_lu_dir'),
species => $self->o('species'),
};
}
sub resource_classes {
my ($self) = @_;
return {
%{$self->SUPER::resource_classes}, # inherit 'default' from the parent class
'test_mem' => { 'LSF' => '-q production -R"select[mem>100] rusage[mem=100]" -M100'},
'default_mem' => { 'LSF' => '-q production -R"select[mem>1000] rusage[mem=1000]" -M1000'},
'medium_mem' => { 'LSF' => '-q production -R"select[mem>2000] rusage[mem=2000]" -M2000'},
'high_mem' => { 'LSF' => '-q production -R"select[mem>4000] rusage[mem=4000]" -M4000'},
};
}
sub pipeline_analyses {
my ($self) = @_;
my @analyses;
push @analyses, (
{
-logic_name => 'init_get_car',
-module => 'Bio::EnsEMBL::Variation::Pipeline::GetCAR::InitGetCAR',
-parameters => {
hgvs_dir => $self->o('hgvs_dir'),
car_lu_dir => $self->o('car_lu_dir'),
} ,
-input_ids => [{}],
-rc_name => 'default_mem',
-max_retry_count => 0,
-flow_into => {
'2->A' => ['get_car_seqname'],
'A->1' => ['finish_get_car'],
}
},
{
-logic_name => 'get_car_seqname',
-module => 'Bio::EnsEMBL::Variation::Pipeline::GetCAR::GetCARSeqname',
-parameters => {
hgvs_dir => $self->o('hgvs_dir'),
car_lu_dir => $self->o('car_lu_dir'),
},
-rc_name => 'default_mem',
-max_retry_count => 0,
-analysis_capacity => 1,
},
{
-logic_name => 'finish_get_car',
-module => 'Bio::EnsEMBL::Variation::Pipeline::GetCAR::FinishGetCAR',
-max_retry_count => 0,
},
);
return \@analyses;
}
1;
| 36.532847 | 110 | 0.614386 |
edd3fcb26617ca5bab1baac5b91e6027eb46b6fd | 96 | pl | Perl | HelloWorld/ProgrammingPerl/ch25/ch25.013.pl | grtlinux/KieaPerl | ed8e1e3359ad0186d5cc4f7ed037e956d2f26c9e | [
"Apache-2.0"
] | null | null | null | HelloWorld/ProgrammingPerl/ch25/ch25.013.pl | grtlinux/KieaPerl | ed8e1e3359ad0186d5cc4f7ed037e956d2f26c9e | [
"Apache-2.0"
] | null | null | null | HelloWorld/ProgrammingPerl/ch25/ch25.013.pl | grtlinux/KieaPerl | ed8e1e3359ad0186d5cc4f7ed037e956d2f26c9e | [
"Apache-2.0"
] | null | null | null | warn "No checksumming!\n" if $] < 3.019;
die "Must have prototyping available\n" if $] < 5.003;
| 32 | 54 | 0.65625 |
edc8d20bd0bd4daf6fabfc8a1a4491103dc2846b | 4,729 | pm | Perl | auto-lib/Paws/DAX/Cluster.pm | 0leksii/aws-sdk-perl | b2132fe3c79a06fd15b6137e8a0eb628de722e0f | [
"Apache-2.0"
] | 164 | 2015-01-08T14:58:53.000Z | 2022-02-20T19:16:24.000Z | auto-lib/Paws/DAX/Cluster.pm | 0leksii/aws-sdk-perl | b2132fe3c79a06fd15b6137e8a0eb628de722e0f | [
"Apache-2.0"
] | 348 | 2015-01-07T22:08:38.000Z | 2022-01-27T14:34:44.000Z | auto-lib/Paws/DAX/Cluster.pm | 0leksii/aws-sdk-perl | b2132fe3c79a06fd15b6137e8a0eb628de722e0f | [
"Apache-2.0"
] | 87 | 2015-04-22T06:29:47.000Z | 2021-09-29T14:45:55.000Z | # Generated by default/object.tt
package Paws::DAX::Cluster;
use Moose;
has ActiveNodes => (is => 'ro', isa => 'Int');
has ClusterArn => (is => 'ro', isa => 'Str');
has ClusterDiscoveryEndpoint => (is => 'ro', isa => 'Paws::DAX::Endpoint');
has ClusterEndpointEncryptionType => (is => 'ro', isa => 'Str');
has ClusterName => (is => 'ro', isa => 'Str');
has Description => (is => 'ro', isa => 'Str');
has IamRoleArn => (is => 'ro', isa => 'Str');
has NodeIdsToRemove => (is => 'ro', isa => 'ArrayRef[Str|Undef]');
has Nodes => (is => 'ro', isa => 'ArrayRef[Paws::DAX::Node]');
has NodeType => (is => 'ro', isa => 'Str');
has NotificationConfiguration => (is => 'ro', isa => 'Paws::DAX::NotificationConfiguration');
has ParameterGroup => (is => 'ro', isa => 'Paws::DAX::ParameterGroupStatus');
has PreferredMaintenanceWindow => (is => 'ro', isa => 'Str');
has SecurityGroups => (is => 'ro', isa => 'ArrayRef[Paws::DAX::SecurityGroupMembership]');
has SSEDescription => (is => 'ro', isa => 'Paws::DAX::SSEDescription');
has Status => (is => 'ro', isa => 'Str');
has SubnetGroup => (is => 'ro', isa => 'Str');
has TotalNodes => (is => 'ro', isa => 'Int');
1;
### main pod documentation begin ###
=head1 NAME
Paws::DAX::Cluster
=head1 USAGE
This class represents one of two things:
=head3 Arguments in a call to a service
Use the attributes of this class as arguments to methods. You shouldn't make instances of this class.
Each attribute should be used as a named argument in the calls that expect this type of object.
As an example, if Att1 is expected to be a Paws::DAX::Cluster object:
$service_obj->Method(Att1 => { ActiveNodes => $value, ..., TotalNodes => $value });
=head3 Results returned from an API call
Use accessors for each attribute. If Att1 is expected to be an Paws::DAX::Cluster object:
$result = $service_obj->Method(...);
$result->Att1->ActiveNodes
=head1 DESCRIPTION
Contains all of the attributes of a specific DAX cluster.
=head1 ATTRIBUTES
=head2 ActiveNodes => Int
The number of nodes in the cluster that are active (i.e., capable of
serving requests).
=head2 ClusterArn => Str
The Amazon Resource Name (ARN) that uniquely identifies the cluster.
=head2 ClusterDiscoveryEndpoint => L<Paws::DAX::Endpoint>
The endpoint for this DAX cluster, consisting of a DNS name, a port
number, and a URL. Applications should use the URL to configure the DAX
client to find their cluster.
=head2 ClusterEndpointEncryptionType => Str
The type of encryption supported by the cluster's endpoint. Values are:
=over
=item *
C<NONE> for no encryption
C<TLS> for Transport Layer Security
=back
=head2 ClusterName => Str
The name of the DAX cluster.
=head2 Description => Str
The description of the cluster.
=head2 IamRoleArn => Str
A valid Amazon Resource Name (ARN) that identifies an IAM role. At
runtime, DAX will assume this role and use the role's permissions to
access DynamoDB on your behalf.
=head2 NodeIdsToRemove => ArrayRef[Str|Undef]
A list of nodes to be removed from the cluster.
=head2 Nodes => ArrayRef[L<Paws::DAX::Node>]
A list of nodes that are currently in the cluster.
=head2 NodeType => Str
The node type for the nodes in the cluster. (All nodes in a DAX cluster
are of the same type.)
=head2 NotificationConfiguration => L<Paws::DAX::NotificationConfiguration>
Describes a notification topic and its status. Notification topics are
used for publishing DAX events to subscribers using Amazon Simple
Notification Service (SNS).
=head2 ParameterGroup => L<Paws::DAX::ParameterGroupStatus>
The parameter group being used by nodes in the cluster.
=head2 PreferredMaintenanceWindow => Str
A range of time when maintenance of DAX cluster software will be
performed. For example: C<sun:01:00-sun:09:00>. Cluster maintenance
normally takes less than 30 minutes, and is performed automatically
within the maintenance window.
=head2 SecurityGroups => ArrayRef[L<Paws::DAX::SecurityGroupMembership>]
A list of security groups, and the status of each, for the nodes in the
cluster.
=head2 SSEDescription => L<Paws::DAX::SSEDescription>
The description of the server-side encryption status on the specified
DAX cluster.
=head2 Status => Str
The current status of the cluster.
=head2 SubnetGroup => Str
The subnet group where the DAX cluster is running.
=head2 TotalNodes => Int
The total number of nodes in the cluster.
=head1 SEE ALSO
This class forms part of L<Paws>, describing an object used in L<Paws::DAX>
=head1 BUGS and CONTRIBUTIONS
The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
=cut
| 25.562162 | 102 | 0.711778 |
ed533adfb83dbe211ac4d09bf5fdadc33e4b2a2a | 1,870 | t | Perl | t/00basic.t | p6-css/CSS-Module-p6 | 39b9bd7d394927a1f4dd981ae6e273b375f9700c | [
"Artistic-2.0"
] | 1 | 2020-09-26T06:43:45.000Z | 2020-09-26T06:43:45.000Z | t/00basic.t | css-raku/CSS-Module-raku | 39b9bd7d394927a1f4dd981ae6e273b375f9700c | [
"Artistic-2.0"
] | 1 | 2017-08-19T20:38:46.000Z | 2018-09-03T08:55:08.000Z | t/00basic.t | css-raku/CSS-Module-raku | 39b9bd7d394927a1f4dd981ae6e273b375f9700c | [
"Artistic-2.0"
] | 1 | 2017-08-19T19:16:20.000Z | 2017-08-19T19:16:20.000Z | #!/usr/bin/env perl6
use Test;
use CSS::Module::CSS1;
use CSS::Module::CSS21;
use CSS::Module::CSS3;
use CSS::Grammar::Test;
use CSS::Writer;
use JSON::Fast;
for "012AF", "012AFc" {
# css21+ unicode is up to 6 digits
nok $_ ~~ /^<CSS::Module::CSS1::unicode>$/, "not css1 unicode: $_";
ok $_ ~~ /^<CSS::Module::CSS21::unicode>$/, "css21 unicode: $_";
ok $_ ~~ /^<CSS::Module::CSS3::unicode>$/, "css3 unicode: $_";
}
# css1 and css21 only recognise latin chars as non-ascii (\o240-\o377)
for '' {
nok $_ ~~ /^<CSS::Module::CSS1::nonascii>$/, "not non-ascii css1: $_";
nok $_ ~~ /^<CSS::Module::CSS21::nonascii>$/, "not non-ascii css21: $_";
ok $_ ~~ /^<CSS::Module::CSS3::nonascii>$/, "non-ascii css3: $_";
}
my CSS::Module $css1 = CSS::Module::CSS1.module;
my CSS::Module $css21 = CSS::Module::CSS21.module;
my CSS::Module $css3 = CSS::Module::CSS3.module;
my CSS::Writer $writer .= new( :terse, :color-names );
for 't/00basic.json'.IO.lines.map({ from-json($_).pairs[0] }) {
my $rule = .key;
my %expected = .value;
my $input = %expected<input>;
for { :module($css1), },
{ :module($css21),},
{ :module($css3), },
{ :module($css3), :lax}
-> % ( :$module!, :$lax=False ) {
my $suite = $module.name;
$suite ~= '(lax)' if $lax;
my $grammar = $module.grammar;
my $actions = $module.actions.new(:$lax);
my %level-tests = %( %expected{$suite} // () );
my %level-expected = %expected, %level-tests;
CSS::Grammar::Test::parse-tests($grammar, $input,
:$rule,
:$suite,
:$actions,
:$writer,
:expected(%level-expected) );
}
}
done-testing;
| 30.655738 | 76 | 0.507487 |
edcc79060e249ca3bf3ab70ce61219934322253f | 1,359 | pm | Perl | PfamLib/Bio/Pfam/Drawing/Layout/Config/GenericMotifConfig.pm | Rfam/Rfam-combined | 3e0494c80b0b5760dfe96fb7a817372e61d4df51 | [
"Apache-2.0"
] | 6 | 2017-01-25T12:53:23.000Z | 2021-03-17T04:52:35.000Z | PfamLib/Bio/Pfam/Drawing/Layout/Config/GenericMotifConfig.pm | Rfam/Rfam-combined | 3e0494c80b0b5760dfe96fb7a817372e61d4df51 | [
"Apache-2.0"
] | 50 | 2015-11-06T10:31:46.000Z | 2021-12-03T16:17:28.000Z | PfamLib/Bio/Pfam/Drawing/Layout/Config/GenericMotifConfig.pm | Rfam/Rfam-combined | 3e0494c80b0b5760dfe96fb7a817372e61d4df51 | [
"Apache-2.0"
] | 2 | 2019-05-30T00:10:26.000Z | 2021-04-12T09:42:17.000Z |
# $Author: jm14 $
package Bio::Pfam::Drawing::Layout::Config::GenericMotifConfig;
use strict;
use warnings;
use Convert::Color;
use Moose;
use Moose::Util::TypeConstraints;
sub configureMotif {
my ($self, $region) = @_;
# set up the shape type
#Now contruct the label
#$self->constructLabel($region);
#Now Colour the Region
$self->_setColour($region);
}
sub constructLabel{
my ($self, $region) = @_;
my $label = 'wibble';
}
#This sets the generic region to a dark grey colour
sub _setColour{
my ($self, $region) = @_;
$region->colour( Convert::Color->new( 'rgb8:bebebe' ) );
}
=head1 COPYRIGHT
Copyright (c) 2007: Genome Research Ltd.
Authors: Rob Finn ([email protected]), John Tate ([email protected])
This is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
details.
You should have received a copy of the GNU General Public License along with
this program. If not, see <http://www.gnu.org/licenses/>.
=cut
1;
| 21.571429 | 77 | 0.72259 |
ed746fc03858255da217f75c01f51feddd0c1efa | 1,050 | pl | Perl | ZimbraServer/src/db/migration/migrate20060929-TypedTombstones.pl | fciubotaru/z-pec | 82335600341c6fb1bb8a471fd751243a90bc4d57 | [
"MIT"
] | 5 | 2019-03-26T07:51:56.000Z | 2021-08-30T07:26:05.000Z | ZimbraServer/src/db/migration/migrate20060929-TypedTombstones.pl | fciubotaru/z-pec | 82335600341c6fb1bb8a471fd751243a90bc4d57 | [
"MIT"
] | 1 | 2015-08-18T19:03:32.000Z | 2015-08-18T19:03:32.000Z | ZimbraServer/src/db/migration/migrate20060929-TypedTombstones.pl | fciubotaru/z-pec | 82335600341c6fb1bb8a471fd751243a90bc4d57 | [
"MIT"
] | 13 | 2015-03-11T00:26:35.000Z | 2020-07-26T16:25:18.000Z | #!/usr/bin/perl
#
# ***** BEGIN LICENSE BLOCK *****
# Zimbra Collaboration Suite Server
# Copyright (C) 2006, 2007, 2008, 2009, 2010 Zimbra, Inc.
#
# The contents of this file are subject to the Zimbra Public License
# Version 1.3 ("License"); you may not use this file except in
# compliance with the License. You may obtain a copy of the License at
# http://www.zimbra.com/license.
#
# Software distributed under the License is distributed on an "AS IS"
# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
# ***** END LICENSE BLOCK *****
#
use strict;
use Migrate;
Migrate::verifySchemaVersion(28);
my @groups = Migrate::getMailboxGroups();
my $sql = "";
foreach my $group (@groups) {
$sql .= addTombstoneTypeColumn($group);
}
Migrate::runSql($sql);
Migrate::updateSchemaVersion(28, 29);
exit(0);
#####################
sub addTombstoneTypeColumn($) {
my ($group) = @_;
my $sql = <<ADD_TYPE_COLUMN_EOF;
ALTER TABLE $group.tombstone
ADD COLUMN type TINYINT AFTER date;
ADD_TYPE_COLUMN_EOF
return $sql;
}
| 22.340426 | 71 | 0.681905 |
ed7f1bc340542f1d82e33d39161a544af41ef197 | 2,161 | pl | Perl | hotpot/Figures/plot_FAST_replica_zipf.pl | lastweek/2022-UCSD-Thesis | 859886a5c8524aa73d7d0784d5d695ec60ff1634 | [
"MIT"
] | 12 | 2022-03-14T03:09:38.000Z | 2022-03-18T16:28:32.000Z | hotpot/Figures/plot_FAST_replica_zipf.pl | lastweek/2022-UCSD-Thesis | 859886a5c8524aa73d7d0784d5d695ec60ff1634 | [
"MIT"
] | null | null | null | hotpot/Figures/plot_FAST_replica_zipf.pl | lastweek/2022-UCSD-Thesis | 859886a5c8524aa73d7d0784d5d695ec60ff1634 | [
"MIT"
] | null | null | null | #proc page
#if @DEVICE in png,gif
scale: 1
#endif
#proc areadef
rectangle: 1 1 12 6
xrange: 1 4
yrange: 0.0 1.0
#proc xaxis
label: Degree of Replication
labeldistance: 0.9
selflocatingstubs: text
1 1
2 2
3 3
4 4
#proc yaxis
label: Ratio (Mig./No-Mig.)
labeldistance: 1.0
#selflocatingstubs: text
stubs: inc 0.2
#proc getdata
file: ../Data/data_FAST_replica_zipf.tab
fieldnames: loc Begin Commit Total
//#proc lineplot
//xfield: loc
//yfield: Begin
//linedetails: color=black width=2 style=0 dashscale=4.5
//pointsymbol: shape=circle color=black radius=0.18 linewidth=2
//legendlabel: begin-xact
#proc lineplot
xfield: loc
yfield: Total
linedetails: color=black width=4 style=3 dashscale=4.5
pointsymbol: shape=diamond color=black radius=0.18 linewidth=2
legendlabel: total-xact-duration
#proc lineplot
xfield: loc
yfield: Commit
linedetails: color=black width=2 style=2 dashscale=4.5
pointsymbol: shape=square color=black radius=0.18 linewidth=2
legendlabel: commit-xact
#proc legend
format: down
location: min+1 min+2.0
seglen: 0.8
//linedetails: color=black width=6 style=10
//pointsymbol: shape=square color=black radius=0.15
//legendlabel: async-nw
#//##proc getdata
#file: ../emulator/data/hlmplanefastssdlatency
#fieldnames: range throughput
#
#//#proc lineplot
#xfield: range
#yfield: throughput
#pointsymbol: shape=square color=black radius=0.1
#linedetails: color=black width=6 style=10
#legendlabel: Hybrid_SSD2
#
#//#proc getdata
#file: ../emulator/data/plmplanelatency
#fieldnames: range throughput
#
#//#proc lineplot
#xfield: range
#yfield: throughput
#linedetails: color=black width=1 style=0
#pointsymbol: shape=nicecircle fillcolor=black radius=0.1
#legendlabel: Page-level_SSD1
#
#
#//#proc getdata
#file: ../emulator/data/plmplanefastssdlatency
#fieldnames: range throughput
#
#///#proc lineplot
#xfield: range
#yfield: throughput
#linedetails: color=black width=6 style=0
#pointsymbol: shape=square fillcolor=black radius=0.1
#legendlabel: Page-level_SSD2
| 22.278351 | 67 | 0.706617 |
edce558a30b43aeee833bb13a70adae938d26ce1 | 156 | pl | Perl | dispatch_table/calc/repl.pl | rcm/hop | 35cda73c58e2289282c82b932be294554065210d | [
"Apache-2.0"
] | null | null | null | dispatch_table/calc/repl.pl | rcm/hop | 35cda73c58e2289282c82b932be294554065210d | [
"Apache-2.0"
] | null | null | null | dispatch_table/calc/repl.pl | rcm/hop | 35cda73c58e2289282c82b932be294554065210d | [
"Apache-2.0"
] | null | null | null | {
my $cnt = 1;
sub prompt {
print "\n$cnt> ";
$cnt++;
}
}
prompt();
while(<>) {
print eval($_) unless $@;
print $@ if $@;
undef $@;
prompt();
}
| 9.75 | 26 | 0.461538 |
edd59788256460dc811f6f4ba8b91c75b5dd2fc5 | 23,573 | pl | Perl | scripts/make-dt.pl | dfint/DwarfTherapistRus-30.1 | f8b5d6edf0788d640f412a52dc0974ea50e261a6 | [
"MIT"
] | 1 | 2021-04-28T21:30:15.000Z | 2021-04-28T21:30:15.000Z | scripts/make-dt.pl | eiz/Dwarf-Therapist | f22a1490e40eb804399de2804babc424db82ca95 | [
"MIT"
] | null | null | null | scripts/make-dt.pl | eiz/Dwarf-Therapist | f22a1490e40eb804399de2804babc424db82ca95 | [
"MIT"
] | null | null | null | #!/usr/bin/perl
use strict;
use warnings;
my ($version, $timestamp, $hash);
open FH, 'version.lisp' or die "Cannot open version";
while (<FH>) {
if (/df-version-str.*\"(.*)\"/) {
$version = $1;
} elsif (/windows-timestamp.*#x([0-9a-f]+)/) {
$timestamp = $1;
} elsif (/linux-hash.*\"(.*)\"/) {
$hash = $1;
}
}
close FH;
sub load_csv(\%$) {
my ($rhash, $fname) = @_;
open FH, $fname or die "Cannot open $fname";
while (<FH>) {
next unless /^\"([^\"]*)\",\"(\d+)\",\"(?:0x([0-9a-fA-F]+))?\",\"[^\"]*\",\"([^\"]*)\",\"([^\"]*)\",\"([^\"]*)\"/;
my ($top, $level, $addr, $type, $name, $target) = ($1,$2,$3,$4,$5,$6);
next if defined $rhash->{$top}{$name};
$rhash->{$top}{$name} = ($type eq 'enum-item' ? $target : hex $addr);
}
close FH;
}
our $complete;
sub lookup_addr(\%$$;$) {
my ($rhash, $top, $name, $bias) = @_;
my $val = $rhash->{$top}{$name};
unless (defined $val) {
$complete = 0;
return 0;
}
return $val + ($bias||0);
}
our @lines;
sub emit_header($) {
my ($name) = @_;
push @lines, '' if @lines;
push @lines, "[$name]";
}
sub emit_addr($\%$$;$) {
my ($name, $rhash, $top, $var, $bias) = @_;
my $val = $rhash->{$top}{$var};
if (defined $val) {
$val += ($bias||0);
if ($val < 0x10000) {
push @lines, sprintf('%s=0x%04x', $name, $val);
} else {
push @lines, sprintf('%s=0x%08x', $name, $val);
}
} else {
$complete = 0;
push @lines, "$name=0x0";
}
}
sub generate_dt_ini($$$$) {
my ($subdir, $version, $checksum, $ssize) = @_;
my %globals;
load_csv %globals, "$subdir/globals.csv";
my %all;
load_csv %all, "$subdir/all.csv";
local $complete = 1;
local @lines;
emit_header 'addresses';
emit_addr 'translation_vector',%globals,'world','world.raws.language.translations';
emit_addr 'language_vector',%globals,'world','world.raws.language.words';
emit_addr 'creature_vector',%globals,'world','world.units.all';
emit_addr 'active_creature_vector',%globals,'world','world.units.active';
emit_addr 'dwarf_race_index',%globals,'ui','ui.race_id';
emit_addr 'squad_vector',%globals,'world','world.squads.all';
emit_addr 'current_year',%globals,'cur_year','cur_year';
emit_addr 'cur_year_tick',%globals,'cur_year_tick','cur_year_tick';
emit_addr 'dwarf_civ_index',%globals,'ui','ui.civ_id';
emit_addr 'races_vector',%globals,'world','world.raws.creatures.all';
emit_addr 'reactions_vector',%globals,'world','world.raws.reactions';
emit_addr 'events_vector',%globals,'world','world.history.events';
emit_addr 'historical_figures_vector',%globals,'world','world.history.figures';
emit_addr 'fake_identities_vector',%globals,'world','world.identities.all';
emit_addr 'fortress_entity',%globals,'ui','ui.main.fortress_entity';
emit_addr 'historical_entities_vector',%globals,'world','world.entities.all';
emit_addr 'itemdef_weapons_vector',%globals,'world','world.raws.itemdefs.weapons';
emit_addr 'itemdef_trap_vector',%globals,'world','world.raws.itemdefs.trapcomps';
emit_addr 'itemdef_toy_vector',%globals,'world','world.raws.itemdefs.toys';
emit_addr 'itemdef_tool_vector',%globals,'world','world.raws.itemdefs.tools';
emit_addr 'itemdef_instrument_vector',%globals,'world','world.raws.itemdefs.instruments';
emit_addr 'itemdef_armor_vector',%globals,'world','world.raws.itemdefs.armor';
emit_addr 'itemdef_ammo_vector',%globals,'world','world.raws.itemdefs.ammo';
emit_addr 'itemdef_siegeammo_vector',%globals,'world','world.raws.itemdefs.siege_ammo';
emit_addr 'itemdef_glove_vector',%globals,'world','world.raws.itemdefs.gloves';
emit_addr 'itemdef_shoe_vector',%globals,'world','world.raws.itemdefs.shoes';
emit_addr 'itemdef_shield_vector',%globals,'world','world.raws.itemdefs.shields';
emit_addr 'itemdef_helm_vector',%globals,'world','world.raws.itemdefs.helms';
emit_addr 'itemdef_pant_vector',%globals,'world','world.raws.itemdefs.pants';
emit_addr 'itemdef_food_vector',%globals,'world','world.raws.itemdefs.food';
emit_addr 'colors_vector',%globals,'world','world.raws.language.colors';
emit_addr 'shapes_vector',%globals,'world','world.raws.language.shapes';
emit_addr 'base_materials',%globals,'world','world.raws.mat_table.builtin';
emit_addr 'inorganics_vector',%globals,'world','world.raws.inorganics';
emit_addr 'plants_vector',%globals,'world','world.raws.plants.all';
emit_addr 'material_templates_vector',%globals,'world','world.raws.material_templates';
emit_addr 'all_syndromes_vector',%globals,'world','world.raws.syndromes.all';
emit_addr 'world_data',%globals,'world','world.world_data';
emit_addr 'active_sites_vector',%all,'world_data','active_site';
emit_addr 'world_site_type',%all,'world_site','type';
emit_addr 'weapons_vector',%globals,'world','world.items.other[WEAPON]';
emit_addr 'shields_vector',%globals,'world','world.items.other[SHIELD]';
emit_addr 'quivers_vector',%globals,'world','world.items.other[QUIVER]';
emit_addr 'crutches_vector',%globals,'world','world.items.other[CRUTCH]';
emit_addr 'backpacks_vector',%globals,'world','world.items.other[BACKPACK]';
emit_addr 'ammo_vector',%globals,'world','world.items.other[AMMO]';
emit_addr 'flasks_vector',%globals,'world','world.items.other[FLASK]';
emit_addr 'pants_vector',%globals,'world','world.items.other[PANTS]';
emit_addr 'armor_vector',%globals,'world','world.items.other[ARMOR]';
emit_addr 'shoes_vector',%globals,'world','world.items.other[SHOES]';
emit_addr 'helms_vector',%globals,'world','world.items.other[HELM]';
emit_addr 'gloves_vector',%globals,'world','world.items.other[GLOVES]';
emit_addr 'artifacts_vector',%globals,'world','world.artifacts.all';
emit_header 'offsets';
emit_addr 'word_table',%all,'language_translation','words';
push @lines, 'string_buffer_offset=0x0000';
emit_header 'word_offsets';
emit_addr 'base',%all,'language_word','word';
emit_addr 'noun_singular',%all,'language_word','forms[Noun]';
emit_addr 'noun_plural',%all,'language_word','forms[NounPlural]';
emit_addr 'adjective',%all,'language_word','forms[Adjective]';
emit_addr 'verb',%all,'language_word','forms[Verb]';
emit_addr 'present_simple_verb',%all,'language_word','forms[Verb3rdPerson]';
emit_addr 'past_simple_verb',%all,'language_word','forms[VerbPast]';
emit_addr 'past_participle_verb',%all,'language_word','forms[VerbPassive]';
emit_addr 'present_participle_verb',%all,'language_word','forms[VerbGerund]';
emit_addr 'words',%all,'language_name','words';
emit_addr 'word_type',%all,'language_name','parts_of_speech';
emit_addr 'language_id',%all,'language_name','language';
emit_header 'general_ref_offsets';
emit_addr 'ref_type',%all,'general_ref::vtable','getType';
emit_addr 'artifact_id',%all,'general_ref_artifact','artifact_id';
emit_addr 'item_id',%all,'general_ref_item','item_id';
emit_header 'race_offsets';
emit_addr 'name_singular',%all,'creature_raw','name';
emit_addr 'name_plural',%all,'creature_raw','name',$ssize;
emit_addr 'adjective',%all,'creature_raw','name',$ssize*2;
emit_addr 'baby_name_singular',%all,'creature_raw','general_baby_name';
emit_addr 'baby_name_plural',%all,'creature_raw','general_baby_name',$ssize;
emit_addr 'child_name_singular',%all,'creature_raw','general_child_name';
emit_addr 'child_name_plural',%all,'creature_raw','general_child_name',$ssize;
emit_addr 'pref_string_vector',%all,'creature_raw','prefstring';
emit_addr 'castes_vector',%all,'creature_raw','caste';
emit_addr 'pop_ratio_vector',%all,'creature_raw','pop_ratio';
emit_addr 'materials_vector',%all,'creature_raw','material';
emit_addr 'flags',%all,'creature_raw','flags';
emit_addr 'tissues_vector',%all,'creature_raw','tissue';
emit_header 'caste_offsets';
emit_addr 'caste_name',%all,'caste_raw','caste_name';
emit_addr 'caste_descr',%all,'caste_raw','description';
emit_addr 'caste_trait_ranges',%all,'caste_raw','personality.a';
emit_addr 'caste_phys_att_ranges',%all,'caste_raw','attributes.phys_att_range';
emit_addr 'baby_age',%all,'caste_raw','misc.baby_age';
emit_addr 'child_age',%all,'caste_raw','misc.child_age';
emit_addr 'adult_size',%all,'caste_raw','misc.adult_size';
emit_addr 'flags',%all,'caste_raw','flags';
emit_addr 'body_info',%all,'caste_raw','body_info';
emit_addr 'skill_rates',%all,'caste_raw','skill_rates';
emit_addr 'caste_att_rates',%all,'caste_raw','attributes.phys_att_rates';
emit_addr 'caste_att_caps',%all,'caste_raw','attributes.phys_att_cap_perc';
emit_addr 'shearable_tissues_vector',%all,'caste_raw','shearable_tissue_layer';
emit_addr 'extracts',%all,'caste_raw','extracts.extract_matidx';
emit_header 'hist_entity_offsets';
emit_addr 'beliefs',%all,'historical_entity','resources.values';
emit_addr 'squads',%all,'historical_entity','squads';
emit_addr 'positions',%all,'historical_entity','positions.own';
emit_addr 'assignments',%all,'historical_entity','positions.assignments';
emit_addr 'assign_hist_id',%all,'entity_position_assignment','histfig';
emit_addr 'assign_position_id',%all,'entity_position_assignment','position_id';
emit_addr 'position_id',%all,'entity_position','id';
emit_addr 'position_name',%all,'entity_position','name';
emit_addr 'position_female_name',%all,'entity_position','name_female';
emit_addr 'position_male_name',%all,'entity_position','name_male';
emit_header 'hist_figure_offsets';
emit_addr 'hist_race',%all,'historical_figure','race';
emit_addr 'hist_name',%all,'historical_figure','name';
emit_addr 'id',%all,'historical_figure','id';
emit_addr 'hist_fig_info',%all,'historical_figure','info';
emit_addr 'reputation',%all,'historical_figure_info','reputation';
emit_addr 'current_ident',%all,'historical_figure_info::anon13','cur_identity';
emit_addr 'fake_name',%all,'identity','name';
emit_addr 'fake_birth_year',%all,'identity','birth_year';
emit_addr 'fake_birth_time',%all,'identity','birth_second';
emit_addr 'kills',%all,'historical_figure_info','kills';
emit_addr 'killed_race_vector',%all,'historical_kills','killed_race';
emit_addr 'killed_undead_vector',%all,'historical_kills','killed_undead';
emit_addr 'killed_counts_vector',%all,'historical_kills','killed_count';
emit_header 'hist_event_offsets';
emit_addr 'event_year',%all,'history_event','year';
emit_addr 'id',%all,'history_event','id';
emit_addr 'killed_hist_id',%all,'history_event_hist_figure_diedst','victim_hf';
emit_header 'item_offsets';
if ($subdir eq 'osx') {
push @lines, 'item_type=0x0004';
} else {
push @lines, 'item_type=0x0001';
}
emit_addr 'item_def',%all,'item_ammost','subtype'; #currently same for all
emit_addr 'id',%all,'item','id';
emit_addr 'general_refs',%all,'item','general_refs';
emit_addr 'stack_size',%all,'item_actual','stack_size';
emit_addr 'wear',%all,'item_actual','wear';
emit_addr 'mat_type',%all,'item_crafted','mat_type';
emit_addr 'mat_index',%all,'item_crafted','mat_index';
emit_addr 'quality',%all,'item_crafted','quality';
emit_header 'item_subtype_offsets';
emit_addr 'sub_type',%all,'itemdef','subtype';
emit_addr 'name',%all,'itemdef_armorst','name';
emit_addr 'name_plural',%all,'itemdef_armorst','name_plural';
emit_addr 'adjective',%all,'itemdef_armorst','name_preplural';
emit_header 'item_filter_offsets';
emit_addr 'item_subtype',%all,'item_filter_spec','item_subtype';
emit_addr 'mat_class',%all,'item_filter_spec','material_class';
emit_addr 'mat_type',%all,'item_filter_spec','mattype';
emit_addr 'mat_index',%all,'item_filter_spec','matindex';
emit_header 'weapon_subtype_offsets';
emit_addr 'single_size',%all,'itemdef_weaponst','two_handed';
emit_addr 'multi_size',%all,'itemdef_weaponst','minimum_size';
emit_addr 'ammo',%all,'itemdef_weaponst','ranged_ammo';
emit_addr 'melee_skill',%all,'itemdef_weaponst','skill_melee';
emit_addr 'ranged_skill',%all,'itemdef_weaponst','skill_ranged';
emit_header 'armor_subtype_offsets';
emit_addr 'layer',%all,'armor_properties','layer';
emit_addr 'mat_name',%all,'itemdef_armorst','material_placeholder';
emit_addr 'other_armor_level',%all,'itemdef_helmst','armorlevel';
emit_addr 'armor_adjective',%all,'itemdef_armorst','adjective';
emit_addr 'armor_level',%all,'itemdef_armorst','armorlevel';
emit_addr 'chest_armor_properties',%all,'itemdef_armorst','props';
emit_addr 'pants_armor_properties',%all,'itemdef_pantsst','props';
emit_addr 'other_armor_properties',%all,'itemdef_helmst','props';
emit_header 'material_offsets';
emit_addr 'solid_name',%all,'material_common','state_name[Solid]';
emit_addr 'liquid_name',%all,'material_common','state_name[Liquid]';
emit_addr 'gas_name',%all,'material_common','state_name[Gas]';
emit_addr 'powder_name',%all,'material_common','state_name[Powder]';
emit_addr 'paste_name',%all,'material_common','state_name[Paste]';
emit_addr 'pressed_name',%all,'material_common','state_name[Pressed]';
emit_addr 'flags',%all,'material_common','flags';
emit_addr 'inorganic_materials_vector',%all,'inorganic_raw','material';
emit_addr 'inorganic_flags',%all,'inorganic_raw','flags';
emit_header 'plant_offsets';
emit_addr 'name',%all,'plant_raw','name';
emit_addr 'name_plural',%all,'plant_raw','name_plural';
emit_addr 'name_leaf_plural',%all,'plant_raw','leaves_plural';
emit_addr 'name_seed_plural',%all,'plant_raw','seed_plural';
emit_addr 'materials_vector',%all,'plant_raw','material';
emit_addr 'flags',%all,'plant_raw','flags';
emit_header 'descriptor_offsets';
emit_addr 'color_name',%all,'descriptor_color','name';
emit_addr 'shape_name_plural',%all,'descriptor_shape','name_plural';
emit_header 'health_offsets';
emit_addr 'parent_id',%all,'body_part_raw','con_part_id';
emit_addr 'body_part_flags',%all,'body_part_raw','flags';
emit_addr 'layers_vector',%all,'body_part_raw','layers';
emit_addr 'number',%all,'body_part_raw','number';
emit_addr 'names_vector',%all,'body_part_raw','name_singular';
emit_addr 'names_plural_vector',%all,'body_part_raw','name_plural';
emit_addr 'layer_tissue',%all,'body_part_layer_raw','tissue_id';
emit_addr 'layer_global_id',%all,'body_part_layer_raw','layer_id';
emit_addr 'tissue_name',%all,'tissue_template','tissue_name_singular';
emit_addr 'tissue_flags',%all,'tissue_template','flags';
emit_header 'dwarf_offsets';
emit_addr 'first_name',%all,'unit','name',lookup_addr(%all,'language_name','first_name');
emit_addr 'nick_name',%all,'unit','name',lookup_addr(%all,'language_name','nickname');
emit_addr 'last_name',%all,'unit','name',lookup_addr(%all,'language_name','words');
emit_addr 'custom_profession',%all,'unit','custom_profession';
emit_addr 'profession',%all,'unit','profession';
emit_addr 'race',%all,'unit','race';
emit_addr 'flags1',%all,'unit','flags1';
emit_addr 'flags2',%all,'unit','flags2';
emit_addr 'flags3',%all,'unit','flags3';
emit_addr 'caste',%all,'unit','caste';
emit_addr 'sex',%all,'unit','sex';
emit_addr 'id',%all,'unit','id';
emit_addr 'animal_type',%all,'unit','training_level';
emit_addr 'civ',%all,'unit','civ_id';
emit_addr 'specific_refs',%all,'unit','specific_refs';
emit_addr 'squad_id',%all,'unit','military.squad_id';
emit_addr 'squad_position',%all,'unit','military.squad_position';
emit_addr 'recheck_equipment',%all,'unit','military.pickup_flags';
emit_addr 'mood',%all,'unit','mood';
emit_addr 'birth_year',%all,'unit','relations.birth_year';
emit_addr 'birth_time',%all,'unit','relations.birth_time';
emit_addr 'pet_owner_id',%all,'unit','relations.pet_owner_id';
emit_addr 'current_job',%all,'unit','job.current_job';
emit_addr 'physical_attrs',%all,'unit','body.physical_attrs';
emit_addr 'body_size',%all,'unit','appearance.body_modifiers';
emit_addr 'size_info',%all,'unit','body.size_info';
emit_addr 'curse',%all,'unit','curse.name';
emit_addr 'curse_add_flags1',%all,'unit','curse.add_tags1';
emit_addr 'turn_count',%all,'unit','curse.time_on_site';
emit_addr 'souls',%all,'unit','status.souls';
emit_addr 'states',%all,'unit','status.misc_traits';
emit_addr 'labors',%all,'unit','status.labors';
emit_addr 'hist_id',%all,'unit','hist_figure_id';
emit_addr 'artifact_name',%all,'unit','status.artifact_name';
emit_addr 'active_syndrome_vector',%all,'unit','syndromes.active';
emit_addr 'syn_sick_flag',%all,'unit_syndrome','flags.is_sick';
emit_addr 'unit_health_info',%all,'unit','health';
emit_addr 'temp_mood',%all,'unit','counters.soldier_mood';
emit_addr 'counters1',%all,'unit','counters.winded';
emit_addr 'counters2',%all,'unit','counters.pain';
emit_addr 'counters3',%all,'unit','counters2.paralysis';
emit_addr 'limb_counters',%all,'unit','status2.limbs_stand_max';
emit_addr 'blood',%all,'unit','body.blood_max';
emit_addr 'body_component_info',%all,'unit','body.components';
emit_addr 'layer_status_vector',%all,'body_component_info','layer_status';
emit_addr 'wounds_vector',%all,'unit','body.wounds';
emit_addr 'mood_skill',%all,'unit','job.mood_skill';
emit_addr 'used_items_vector',%all,'unit','used_items';
emit_addr 'affection_level',%all,'unit_item_use','affection_level';
emit_addr 'inventory',%all,'unit','inventory';
emit_addr 'inventory_item_mode',%all,'unit_inventory_item','mode';
emit_addr 'inventory_item_bodypart',%all,'unit_inventory_item','body_part_id';
emit_header 'syndrome_offsets';
emit_addr 'cie_effects',%all,'syndrome','ce';
emit_addr 'cie_end',%all,'creature_interaction_effect','end';
emit_addr 'cie_first_perc',%all,'creature_interaction_effect_phys_att_changest','phys_att_perc'; #same for mental
emit_addr 'cie_phys',%all,'creature_interaction_effect_phys_att_changest','phys_att_add';
emit_addr 'cie_ment',%all,'creature_interaction_effect_ment_att_changest','ment_att_add';
emit_addr 'syn_classes_vector',%all,'syndrome','syn_class';
emit_addr 'trans_race_id',%all,'creature_interaction_effect_body_transformationst','race';
emit_header 'unit_wound_offsets';
emit_addr 'parts',%all,'unit_wound','parts';
emit_addr 'id',%all,'unit_wound::anon2','body_part_id';
emit_addr 'layer',%all,'unit_wound::anon2','layer_idx';
emit_addr 'general_flags',%all,'unit_wound','flags';
emit_addr 'flags1',%all,'unit_wound::anon2','flags1';
emit_addr 'flags2',%all,'unit_wound::anon2','flags2';
emit_addr 'effects_vector',%all,'unit_wound::anon2','effect_type';
emit_addr 'bleeding',%all,'unit_wound::anon2','bleeding';
emit_addr 'pain',%all,'unit_wound::anon2','pain';
emit_addr 'cur_pen',%all,'unit_wound::anon2','cur_penetration_perc';
emit_addr 'max_pen',%all,'unit_wound::anon2','max_penetration_perc';
emit_header 'soul_details';
emit_addr 'name',%all,'unit_soul','name';
emit_addr 'orientation',%all,'unit_soul','orientation_flags';
emit_addr 'mental_attrs',%all,'unit_soul','mental_attrs';
emit_addr 'skills',%all,'unit_soul','skills';
emit_addr 'preferences',%all,'unit_soul','preferences';
emit_addr 'personality',%all,'unit_soul','personality';
emit_addr 'beliefs',%all,'unit_personality','values';
emit_addr 'emotions',%all,'unit_personality','emotions';
emit_addr 'goals',%all,'unit_personality','dreams';
emit_addr 'goal_realized',%all,'unit_personality::anon5','unk8';
emit_addr 'traits',%all,'unit_personality','traits';
emit_addr 'stress_level',%all,'unit_personality','stress_level';
emit_header 'emotion_offsets';
emit_addr 'emotion_type',%all,'unit_personality::anon4','type';
emit_addr 'strength',%all,'unit_personality::anon4','strength';
emit_addr 'thought_id',%all,'unit_personality::anon4','thought';
emit_addr 'sub_id',%all,'unit_personality::anon4','subthought';
emit_addr 'level',%all,'unit_personality::anon4','severity';
emit_addr 'year',%all,'unit_personality::anon4','year';
emit_addr 'year_tick',%all,'unit_personality::anon4','year_tick';
emit_header 'job_details';
emit_addr 'id',%all,'job','job_type';
emit_addr 'mat_type',%all,'job','mat_type';
emit_addr 'mat_index',%all,'job','mat_index';
emit_addr 'mat_category',%all,'job','material_category';
emit_addr 'on_break_flag',%all,'misc_trait_type','OnBreak';
emit_addr 'sub_job_id',%all,'job','reaction_name';
emit_addr 'reaction',%all,'reaction','name';
emit_addr 'reaction_skill',%all,'reaction','skill';
emit_header 'squad_offsets';
emit_addr 'id',%all,'squad','id';
emit_addr 'name',%all,'squad','name';
emit_addr 'alias',%all,'squad','alias';
emit_addr 'members',%all,'squad','positions';
emit_addr 'carry_food',%all,'squad','carry_food';
emit_addr 'carry_water',%all,'squad','carry_water';
emit_addr 'ammunition',%all,'squad','ammunition';
emit_addr 'quiver',%all,'squad_position','quiver';
emit_addr 'backpack',%all,'squad_position','backpack';
emit_addr 'flask',%all,'squad_position','flask';
emit_addr 'armor_vector',%all,'squad_position','uniform[body]';
emit_addr 'helm_vector',%all,'squad_position','uniform[head]';
emit_addr 'pants_vector',%all,'squad_position','uniform[pants]';
emit_addr 'gloves_vector',%all,'squad_position','uniform[gloves]';
emit_addr 'shoes_vector',%all,'squad_position','uniform[shoes]';
emit_addr 'shield_vector',%all,'squad_position','uniform[shield]';
emit_addr 'weapon_vector',%all,'squad_position','uniform[weapon]';
emit_addr 'uniform_item_filter',%all,'squad_uniform_spec','item_filter';
emit_addr 'uniform_indiv_choice',%all,'squad_uniform_spec','indiv_choice';
my $body_str = join("\n",@lines);
my $complete_str = ($complete ? 'true' : 'false');
open OUT, ">$subdir/therapist.ini" or die "Cannot open output file";
print OUT <<__END__;
[info]
checksum=0x$checksum
version_name=$version
complete=$complete_str
$body_str
[valid_flags_2]
size=0
[invalid_flags_1]
size=9
1\\name=a skeleton
1\\value=0x00002000
2\\name=a merchant
2\\value=0x00000040
3\\name=outpost liason or diplomat
3\\value=0x00000800
4\\name=an invader or hostile
4\\value=0x00020000
5\\name=an invader or hostile
5\\value=0x00080000
6\\name=resident, invader or ambusher
6\\value=0x00600000
7\\name=part of a merchant caravan
7\\value=0x00000080
8\\name="Dead, Jim."
8\\value=0x00000002
9\\name=marauder
9\\value=0x00000010
[invalid_flags_2]
size=5
1\\name="killed, Jim."
1\\value=0x00000080
2\\name=from the Underworld. SPOOKY!
2\\value=0x00040000
3\\name=resident
3\\value=0x00080000
4\\name=uninvited visitor
4\\value=0x00400000
5\\name=visitor
5\\value=0x00800000
[invalid_flags_3]
size=1
1\\name=a ghost
1\\value=0x00001000
__END__
close OUT;
}
generate_dt_ini 'linux', $version, substr($hash,0,8), 4;
generate_dt_ini 'windows', $version.' (graphics)', $timestamp, 0x1C;
generate_dt_ini 'osx', $version, substr($hash,0,8), 4; | 48.010183 | 122 | 0.704789 |
edc09a4e1f5d4fd9ff1b197470a48434c4425ce5 | 8,742 | pm | Perl | lib/Mojolicious/Plugin/PODViewer.pm | preaction/Mojolicious-Plugin-PODViewer | 4cbe2b46466a591945aa91e33de3792ffaa840e9 | [
"Artistic-1.0"
] | 1 | 2020-02-19T13:45:47.000Z | 2020-02-19T13:45:47.000Z | lib/Mojolicious/Plugin/PODViewer.pm | preaction/Mojolicious-Plugin-PODViewer | 4cbe2b46466a591945aa91e33de3792ffaa840e9 | [
"Artistic-1.0"
] | 10 | 2019-01-20T20:01:53.000Z | 2021-05-10T05:42:44.000Z | lib/Mojolicious/Plugin/PODViewer.pm | preaction/Mojolicious-Plugin-PODViewer | 4cbe2b46466a591945aa91e33de3792ffaa840e9 | [
"Artistic-1.0"
] | 5 | 2019-01-19T09:05:40.000Z | 2022-02-12T02:54:34.000Z | package Mojolicious::Plugin::PODViewer;
our $VERSION = '0.008';
# ABSTRACT: POD renderer plugin
=encoding utf8
=head1 SYNOPSIS
# Mojolicious (with documentation browser under "/perldoc")
my $route = $app->plugin('PODViewer');
my $route = $app->plugin(PODViewer => {name => 'foo'});
my $route = $app->plugin(PODViewer => {preprocess => 'epl'});
# Mojolicious::Lite (with documentation browser under "/perldoc")
my $route = plugin 'PODViewer';
my $route = plugin PODViewer => {name => 'foo'};
my $route = plugin PODViewer => {preprocess => 'epl'};
# Without documentation browser
plugin PODViewer => {no_perldoc => 1};
# foo.html.ep
%= pod_to_html "=head1 TEST\n\nC<123>"
# foo.html.pod
=head1 <%= uc 'test' %>
=head1 DESCRIPTION
L<Mojolicious::Plugin::PODViewer> is a renderer for Perl's POD (Plain
Old Documentation) format. It includes a browser to browse the Perl
module documentation as a website.
This is a fork of the (deprecated) L<Mojolicious::Plugin::PODRenderer>.
=head1 OPTIONS
L<Mojolicious::Plugin::PODViewer> supports the following options.
=head2 name
# Mojolicious::Lite
plugin PODViewer => {name => 'foo'};
Handler name, defaults to C<pod>.
=head2 route
The L<route|Mojolicious::Routes::Route> to add documentation to. Defaults to
C<< $app->routes->any('/perldoc') >>. The new route will have a name of
C<plugin.podviewer>.
=head2 default_module
The default module to show. Defaults to C<Mojolicious::Guides>.
=head2 allow_modules
An arrayref of regular expressions that match modules to allow. At least
one of the regular expressions must match. Disallowed modules will be
redirected to the appropriate page on L<http://metacpan.org>.
=head2 layout
The layout to use. Defaults to C<podviewer>.
=head2 no_perldoc
# Mojolicious::Lite
plugin PODViewer => {no_perldoc => 1};
Disable L<Mojolicious::Guides> documentation browser that will otherwise be
available under C</perldoc>.
=head2 preprocess
# Mojolicious::Lite
plugin PODViewer => {preprocess => 'epl'};
Name of handler used to preprocess POD, defaults to C<ep>.
=head1 HELPERS
L<Mojolicious::Plugin::PODViewer> implements the following helpers.
=head2 pod_to_html
%= pod_to_html '=head2 lalala'
<%= pod_to_html begin %>=head2 lalala<% end %>
Render POD to HTML without preprocessing.
=head1 TEMPLATES
L<Mojolicious::Plugin::PODViewer> bundles the following templates. To
override this template with your own, create a template with the same name.
=head2 podviewer/perldoc.html.ep
This template displays the POD for a module. The HTML for the documentation
is in the C<perldoc> content section (C<< <%= content 'perldoc' %> >>).
The template has the following stash values:
=over
=item module
The current module, with parts separated by C</>.
=item cpan
A link to L<http://metacpan.org> for the current module.
=item topics
An array of arrays of topics in the documentation. Each inner array is
a set of pairs of C<link text> and C<link href> suitable to be passed
directly to the C<link_to> helper. New topics are started by a C<=head1>
tag, and include all lower-level headings.
=back
=head2 layouts/podviewer.html.ep
The layout for rendering POD pages. Use this to add stylesheets,
JavaScript, and additional navigation. Set the C<layout> option to
change this template.
=head1 METHODS
L<Mojolicious::Plugin::PODViewer> inherits all methods from
L<Mojolicious::Plugin> and implements the following new ones.
=head2 register
my $route = $plugin->register(Mojolicious->new);
my $route = $plugin->register(Mojolicious->new, {name => 'foo'});
Register renderer and helper in L<Mojolicious> application.
=head1 SEE ALSO
L<Mojolicious>, L<Mojolicious::Guides>, L<https://mojolicious.org>.
=cut
use Mojo::Base 'Mojolicious::Plugin';
use Mojo::Asset::File;
use Mojo::ByteStream;
use Mojo::DOM;
use Mojo::File 'path';
use Mojo::URL;
use Pod::Simple::XHTML;
use Pod::Simple::Search;
sub register {
my ($self, $app, $conf) = @_;
my $preprocess = $conf->{preprocess} || 'ep';
$app->renderer->add_handler(
$conf->{name} || 'pod' => sub {
my ($renderer, $c, $output, $options) = @_;
$renderer->handlers->{$preprocess}($renderer, $c, $output, $options);
$$output = _pod_to_html($$output) if defined $$output;
}
);
$app->helper(
pod_to_html => sub { shift; Mojo::ByteStream->new(_pod_to_html(@_)) });
# Perldoc browser
return undef if $conf->{no_perldoc};
push @{ $app->renderer->classes }, __PACKAGE__;
my $default_module = $conf->{default_module} // 'Mojolicious::Guides';
$default_module =~ s{::}{/}g;
my $defaults = {
module => $default_module,
( $conf->{layout} ? ( layout => $conf->{layout} ) : () ),
allow_modules => $conf->{allow_modules} // [ qr{} ],
format => undef,
};
my $route = $conf->{route} ||= $app->routes->any( '/perldoc' );
return $route->any( '/:module'
=> $defaults
=> [format => [qw( html txt )], module => qr/[^.]+/]
=> \&_perldoc,
)->name('plugin.podviewer');
}
sub _indentation {
(sort map {/^(\s+)/} @{shift()})[0];
}
sub _html {
my ($c, $src) = @_;
# Rewrite links
my $dom = Mojo::DOM->new(_pod_to_html($src));
my $base = 'https://metacpan.org/pod/';
$dom->find('a[href]')->map('attr')->each(sub {
if ($_->{href} =~ m!^\Q$base\E([:\w]+)!) {
my $module = $1;
return undef
unless grep { $module =~ /$_/ } @{ $c->stash('allow_modules') || [] };
$_->{href} =~ s{^\Q$base$module\E}{$c->url_for(module => $module)}e;
$_->{href} =~ s!::!/!gi
}
});
# Rewrite code blocks for syntax highlighting and correct indentation
for my $e ($dom->find('pre > code')->each) {
next if (my $str = $e->content) =~ /^\s*(?:\$|Usage:)\s+/m;
next unless $str =~ /[\$\@\%]\w|->\w|^use\s+\w/m;
my $attrs = $e->attr;
my $class = $attrs->{class};
$attrs->{class} = defined $class ? "$class prettyprint" : 'prettyprint';
}
# Rewrite headers
my $toc = Mojo::URL->new->fragment('toc');
my @topics;
for my $e ($dom->find('h1, h2, h3, h4')->each) {
push @topics, [] if $e->tag eq 'h1' || !@topics;
my $link = Mojo::URL->new->fragment($e->{id});
push @{$topics[-1]}, my $text = $e->all_text, $link;
my $permalink = $c->link_to('#' => $link, class => 'permalink');
$e->content($permalink . $c->link_to($text => $toc));
}
# Try to find a title
my $title = 'Perldoc';
$dom->find('h1 + p')->first(sub { $title = shift->all_text });
# Combine everything to a proper response
$c->content_for(perldoc => "$dom");
$c->render('podviewer/perldoc', title => $title, topics => \@topics);
}
sub _perldoc {
my $c = shift;
# Find module or redirect to CPAN
my $module = join '::', split('/', $c->param('module'));
$c->stash(cpan => "https://metacpan.org/pod/$module");
return $c->redirect_to( $c->stash( 'cpan' ) )
unless grep { $module =~ /$_/ } @{ $c->stash( 'allow_modules' ) || [] };
my $path
= Pod::Simple::Search->new->find($module, map { $_, "$_/pods" } @INC);
return $c->redirect_to($c->stash('cpan')) unless $path && -r $path;
$c->stash->{layout} //= 'podviewer';
my $src = path($path)->slurp;
$c->respond_to(txt => {data => $src}, html => sub { _html($c, $src) });
}
sub _pod_to_html {
return '' unless defined(my $pod = ref $_[0] eq 'CODE' ? shift->() : shift);
my $parser = Pod::Simple::XHTML->new;
$parser->perldoc_url_prefix('https://metacpan.org/pod/');
$parser->$_('') for qw(html_header html_footer);
$parser->strip_verbatim_indent(\&_indentation);
$parser->output_string(\(my $output));
return $@ unless eval { $parser->parse_string_document("$pod"); 1 };
return $output;
}
1;
__DATA__
@@ layouts/podviewer.html.ep
<!DOCTYPE html>
<html>
<head>
<title><%= title %></title>
</head>
<body>
%= content
</body>
</html>
@@ podviewer/perldoc.html.ep
<div class="crumbs">
% my $path = '';
% for my $part (split '/', $module) {
%= '::' if $path
% $path .= $path ? "/$part" : $part;
%= link_to $part => 'plugin.podviewer', { module => $path }
% }
<span class="more">
(<%= link_to 'source' => 'plugin.podviewer',
{ module => $module, format => 'txt' } %>,
<%= link_to 'CPAN' => $cpan %>)
</span>
</div>
<h1><a id="toc">CONTENTS</a></h1>
<ul>
% for my $topic (@$topics) {
<li>
%= link_to splice(@$topic, 0, 2)
% if (@$topic) {
<ul>
% while (@$topic) {
<li><%= link_to splice(@$topic, 0, 2) %></li>
% }
</ul>
% }
</li>
% }
</ul>
%= content 'perldoc'
| 27.31875 | 78 | 0.617593 |
73e81f4b873000e2077e4d8e212796caa3192d4f | 5,174 | pl | Perl | libraries/wallet/generate_api_documentation.pl | futurepia/futurepia | 31163047b18082223a86ec4f95a820748275ceaa | [
"MIT"
] | 3 | 2019-12-24T13:49:22.000Z | 2021-01-02T08:26:13.000Z | libraries/wallet/generate_api_documentation.pl | futurepia/futurepia | 31163047b18082223a86ec4f95a820748275ceaa | [
"MIT"
] | 4 | 2020-01-01T20:41:39.000Z | 2021-11-30T16:31:10.000Z | libraries/wallet/generate_api_documentation.pl | futurepia/futurepia | 31163047b18082223a86ec4f95a820748275ceaa | [
"MIT"
] | 5 | 2019-03-30T12:53:31.000Z | 2021-06-10T16:22:11.000Z | #! /usr/bin/perl
use Text::Wrap;
use IO::File;
require './doxygen/perlmod/DoxyDocs.pm';
# For cygwin (You have to change below path according to your personal settings. and do comment above require.)
#require '/cygdrive/d/40_VC_Project/futurepia/build/libraries/wallet/doxygen/perlmod/DoxyDocs.pm';
my($outputFileName) = @ARGV;
die "usage: $0 output_file_name" unless $outputFileName;
my $outFile = new IO::File($outputFileName, "w")
or die "Error opening output file: $!";
my $fileHeader = <<'END';
/** GENERATED FILE **/
#include <set>
#include <futurepia/wallet/api_documentation.hpp>
#include <futurepia/wallet/wallet.hpp>
namespace futurepia { namespace wallet {
namespace detail
{
struct api_method_name_collector_visitor
{
std::set<std::string> method_names;
template<typename R, typename... Args>
void operator()( const char* name, std::function<R(Args...)>& memb )
{
method_names.emplace(name);
}
};
}
api_documentation::api_documentation()
{
END
$outFile->print($fileHeader);
for my $class (@{$doxydocs->{classes}})
{
if ($class->{name} eq 'futurepia::wallet::wallet_api')
{
for my $member (@{$class->{public_methods}->{members}})
{
if ($member->{kind} eq 'function')
{
my @params = map { join(' ', cleanupDoxygenType($_->{type}), $_->{declaration_name}) } @{$member->{parameters}};
my $briefDescription = sprintf("%40s %s(%s)\n", cleanupDoxygenType($member->{type}), $member->{name}, join(', ', @params));
my $escapedBriefDescription = "\"" . escapeStringForC($briefDescription) . "\"";
my %paramInfo = map { $_->{declaration_name} => { type => $_->{type}} } @{$member->{parameters}};
my $escapedDetailedDescription = "\"\"\n";
if ($member->{detailed}->{doc})
{
my $docString = formatDocComment($member->{detailed}->{doc}, \%paramInfo);
for my $line (split(/\n/, $docString))
{
$escapedDetailedDescription .= " \"" . escapeStringForC($line . "\n") . "\"\n";
}
}
my $codeFragment = <<"END";
{
method_description this_method;
this_method.method_name = "$member->{name}";
this_method.brief_description = $escapedBriefDescription;
this_method.detailed_description = $escapedDetailedDescription;
method_descriptions.insert(this_method);
}
END
$outFile->print($codeFragment);
}
}
}
}
my $fileFooter = <<'END';
fc::api<wallet_api> tmp;
detail::api_method_name_collector_visitor visitor;
tmp->visit(visitor);
for (auto iter = method_descriptions.begin(); iter != method_descriptions.end();)
if (visitor.method_names.find(iter->method_name) == visitor.method_names.end())
iter = method_descriptions.erase(iter);
else
++iter;
}
} } // end namespace futurepia::wallet
END
$outFile->print($fileFooter);
$outFile->close();
sub cleanupDoxygenType
{
my($type) = @_;
$type =~ s/< /</g;
$type =~ s/ >/>/g;
return $type;
}
sub formatDocComment
{
my($doc, $paramInfo) = @_;
my $bodyDocs = '';
my $paramDocs = '';
my $returnDocs = '';
for (my $i = 0; $i < @{$doc}; ++$i)
{
if ($doc->[$i] eq 'params')
{
$paramDocs .= "Parameters:\n";
@parametersList = @{$doc->[$i + 1]};
for my $parameter (@parametersList)
{
my $declname = $parameter->{parameters}->[0]->{name};
my $decltype = cleanupDoxygenType($paramInfo->{$declname}->{type});
$paramDocs .= Text::Wrap::fill(' ', ' ', "$declname: " . formatDocComment($parameter->{doc}) . " (type: $decltype)") . "\n";
}
++$i;
}
elsif ($doc->[$i]->{return})
{
$returnDocs .= "Returns\n";
$returnDocs .= Text::Wrap::fill(' ',' ', formatDocComment($doc->[$i]->{return})) . "\n";
}
else
{
my $docElement = $doc->[$i];
if ($docElement->{type} eq 'text' or $docElement->{type} eq 'url')
{
$bodyDocs .= $docElement->{content};
}
elsif ($docElement->{type} eq 'parbreak')
{
$bodyDocs .= "\n\n";
}
elsif ($docElement->{type} eq 'style' and $docElement->{style} eq 'code')
{
$bodyDocs .= "'";
}
}
}
$bodyDocs =~ s/^\s+|\s+$//g;
$bodyDocs = Text::Wrap::fill('', '', $bodyDocs);
$paramDocs =~ s/^\s+|\s+$//g;
$returnDocs =~ s/^\s+|\s+$//g;
my $result = Text::Wrap::fill('', '', $bodyDocs);
$result .= "\n\n" . $paramDocs if $paramDocs;
$result .= "\n\n" . $returnDocs if $returnDocs;
return $result;
}
sub escapeCharForCString
{
my($char) = @_;
return "\\a" if $char eq "\x07";
return "\\b" if $char eq "\x08";
return "\\f" if $char eq "\x0c";
return "\\n" if $char eq "\x0a";
return "\\r" if $char eq "\x0d";
return "\\t" if $char eq "\x09";
return "\\v" if $char eq "\x0b";
return "\\\"" if $char eq "\x22";
return "\\\\" if $char eq "\x5c";
return $char;
}
sub escapeStringForC
{
my($str) = @_;
return join('', map { escapeCharForCString($_) } split('', $str));
}
| 28.273224 | 142 | 0.565906 |
ed6456f85ba92e9287013b119dd31ba7dafb6e8d | 33,437 | pm | Perl | Image-ExifTool-11.28/lib/Image/ExifTool/TagInfoXML.pm | mpavlak25/Photo-Gradients | b732083a4827db9bbe9dc9cf4e3fd31734e52f22 | [
"Unlicense"
] | null | null | null | Image-ExifTool-11.28/lib/Image/ExifTool/TagInfoXML.pm | mpavlak25/Photo-Gradients | b732083a4827db9bbe9dc9cf4e3fd31734e52f22 | [
"Unlicense"
] | null | null | null | Image-ExifTool-11.28/lib/Image/ExifTool/TagInfoXML.pm | mpavlak25/Photo-Gradients | b732083a4827db9bbe9dc9cf4e3fd31734e52f22 | [
"Unlicense"
] | null | null | null | #------------------------------------------------------------------------------
# File: TagInfoXML.pm
#
# Description: Read/write tag information XML database
#
# Revisions: 2009/01/28 - P. Harvey Created
#------------------------------------------------------------------------------
package Image::ExifTool::TagInfoXML;
use strict;
require Exporter;
use vars qw($VERSION @ISA $makeMissing);
use Image::ExifTool qw(:Utils :Vars);
use Image::ExifTool::XMP;
$VERSION = '1.30';
@ISA = qw(Exporter);
# set this to a language code to generate Lang module with 'MISSING' entries
$makeMissing = '';
sub LoadLangModules($;$);
sub WriteLangModule($$;$);
sub NumbersFirst;
# names for acknowledgements in the POD documentation
my %credits = (
cs => 'Jens Duttke and Petr MichE<aacute>lek',
de => 'Jens Duttke and Herbert Kauer',
es => 'Jens Duttke, Santiago del BrE<iacute>o GonzE<aacute>lez and Emilio Sancha',
fi => 'Jens Duttke and Jarkko ME<auml>kineva',
fr => 'Jens Duttke, Bernard Guillotin, Jean Glasser, Jean Piquemal, Harry Nizard and Alphonse Philippe',
it => 'Jens Duttke, Ferdinando Agovino, Emilio Dati and Michele Locati',
ja => 'Jens Duttke and Kazunari Nishina',
ko => 'Jens Duttke and Jeong Beom Kim',
nl => 'Jens Duttke, Peter Moonen, Herman Beld and Peter van der Laan',
pl => 'Jens Duttke, Przemyslaw Sulek and Kacper Perschke',
ru => 'Jens Duttke, Sergey Shemetov, Dmitry Yerokhin and Anton Sukhinov',
sv => 'Jens Duttke and BjE<ouml>rn SE<ouml>derstrE<ouml>m',
'tr' => 'Jens Duttke, Hasan Yildirim and Cihan Ulusoy',
zh_cn => 'Jens Duttke and Haibing Zhong',
zh_tw => 'Jens Duttke and MikeF',
);
# translate country codes to language codes
my %translateLang = (
ch_s => 'zh_cn',
ch_cn => 'zh_cn',
ch_tw => 'zh_tw',
cz => 'cs',
jp => 'ja',
kr => 'ko',
se => 'sv',
);
my $numbersFirst = 1; # set to -1 to sort numbers last, or 2 to put negative numbers last
my $caseInsensitive; # used internally by sort routine
#------------------------------------------------------------------------------
# Utility to print tag information database as an XML list
# Inputs: 0) output file name (undef to send to console),
# 1) group name (may be undef), 2) options hash ('Flags','NoDesc','Lang')
# Returns: true on success
sub Write(;$$%)
{
local ($_, *PTIFILE);
my ($file, $group, %opts) = @_;
my @groups = split ':', $group if $group;
my $et = new Image::ExifTool;
my ($fp, $tableName, %langInfo, @langs, $defaultLang);
Image::ExifTool::LoadAllTables(); # first load all our tables
unless ($opts{NoDesc}) {
$defaultLang = $Image::ExifTool::defaultLang;
LoadLangModules(\%langInfo, $opts{Lang}); # load necessary Lang modules
if ($opts{Lang}) {
@langs = grep /^$opts{Lang}$/i, keys %langInfo;
} else {
@langs = sort keys %langInfo;
}
}
if (defined $file) {
open PTIFILE, ">$file" or return 0;
$fp = \*PTIFILE;
} else {
$fp = \*STDOUT;
}
print $fp "<?xml version='1.0' encoding='UTF-8'?>\n";
print $fp "<!-- Generated by Image::ExifTool $Image::ExifTool::VERSION -->\n";
print $fp "<taginfo>\n\n";
# loop through all tables and save tag names to %allTags hash
foreach $tableName (sort keys %allTables) {
my $table = GetTagTable($tableName);
my $grps = $$table{GROUPS};
my ($tagID, $didTag);
# sort in same order as tag name documentation
$caseInsensitive = ($tableName =~ /::XMP::/);
# get list of languages defining elements in this table
my $isBinary = ($$table{PROCESS_PROC} and
$$table{PROCESS_PROC} eq \&Image::ExifTool::ProcessBinaryData);
# generate flattened tag names for structure fields if this is an XMP table
if ($$table{GROUPS} and $$table{GROUPS}{0} eq 'XMP') {
Image::ExifTool::XMP::AddFlattenedTags($table);
}
$numbersFirst = 2;
$numbersFirst = -1 if $$table{VARS} and $$table{VARS}{ALPHA_FIRST};
my @keys = sort NumbersFirst TagTableKeys($table);
$numbersFirst = 1;
# loop through all tag ID's in this table
foreach $tagID (@keys) {
my @infoArray = GetTagInfoList($table, $tagID);
my $xmlID = Image::ExifTool::XMP::FullEscapeXML($tagID);
# get a list of languages defining elements for this ID
my ($index, $fam);
PTILoop: for ($index=0; $index<@infoArray; ++$index) {
my $tagInfo = $infoArray[$index];
# don't list subdirectories unless they are writable
next unless $$tagInfo{Writable} or not $$tagInfo{SubDirectory};
if (@groups) {
my @tg = $et->GetGroup($tagInfo);
foreach $group (@groups) {
next PTILoop unless grep /^$group$/i, @tg;
}
}
unless ($didTag) {
my $tname = $$table{SHORT_NAME};
print $fp "<table name='${tname}' g0='$$grps{0}' g1='$$grps{1}' g2='$$grps{2}'>\n";
unless ($opts{NoDesc}) {
# print table description
my $desc = $$table{TABLE_DESC};
unless ($desc) {
($desc = $tname) =~ s/::Main$//;
$desc =~ s/::/ /g;
}
# print alternate language descriptions
print $fp " <desc lang='en'>$desc</desc>\n";
foreach (@langs) {
$desc = $langInfo{$_}{$tableName} or next;
$desc = Image::ExifTool::XMP::EscapeXML($desc);
print $fp " <desc lang='${_}'>$desc</desc>\n";
}
}
$didTag = 1;
}
my $name = $$tagInfo{Name};
my $ind = @infoArray > 1 ? " index='${index}'" : '';
my $format = $$tagInfo{Writable} || $$table{WRITABLE};
my $writable = $format ? 'true' : 'false';
# check our conversions to make sure we can really write this tag
if ($writable eq 'true') {
foreach ('PrintConv','ValueConv') {
next unless $$tagInfo{$_};
next if $$tagInfo{$_ . 'Inv'};
next if ref($$tagInfo{$_}) =~ /^(HASH|ARRAY)$/;
next if $$tagInfo{WriteAlso};
$writable = 'false';
last;
}
}
$format = $$tagInfo{Format} || $$table{FORMAT} if not defined $format or $format eq '1';
$format = 'struct' if $$tagInfo{Struct};
if (defined $format) {
$format =~ s/\[.*\$.*\]//; # remove expressions from format
} elsif ($isBinary) {
$format = 'int8u';
} else {
$format = '?';
}
my $count = '';
if ($format =~ s/\[.*?(\d*)\]$//) {
$count = " count='${1}'" if length $1;
} elsif ($$tagInfo{Count} and $$tagInfo{Count} > 1) {
$count = " count='$$tagInfo{Count}'";
}
my @groups = $et->GetGroup($tagInfo);
my $writeGroup = $$tagInfo{WriteGroup} || $$table{WRITE_GROUP};
if ($writeGroup and $writeGroup ne 'Comment') {
$groups[1] = $writeGroup; # use common write group for group 1
}
# add group names if different from table defaults
my $grp = '';
for ($fam=0; $fam<3; ++$fam) {
$grp .= " g$fam='$groups[$fam]'" if $groups[$fam] ne $$grps{$fam};
}
# add flags if necessary
if ($opts{Flags}) {
my @flags;
foreach (qw(Avoid Binary List Mandatory Unknown)) {
push @flags, $_ if $$tagInfo{$_};
}
push @flags, $$tagInfo{List} if $$tagInfo{List} and $$tagInfo{List} =~ /^(Alt|Bag|Seq)$/;
push @flags, 'Flattened' if defined $$tagInfo{Flat};
push @flags, 'Unsafe' if $$tagInfo{Protected} and $$tagInfo{Protected} & 0x01;
push @flags, 'Protected' if $$tagInfo{Protected} and $$tagInfo{Protected} & 0x02;
push @flags, 'Permanent' if $$tagInfo{Permanent} or
($groups[0] eq 'MakerNotes' and not defined $$tagInfo{Permanent});
$grp = " flags='" . join(',', sort @flags) . "'$grp" if @flags;
}
print $fp " <tag id='${xmlID}' name='${name}'$ind type='${format}'$count writable='${writable}'$grp";
if ($opts{NoDesc}) {
# short output format
print $fp "/>\n"; # empty tag element
next; # no descriptions or values
} else {
print $fp ">";
}
my $desc = $$tagInfo{Description};
$desc = Image::ExifTool::MakeDescription($name) unless defined $desc;
# add alternate language descriptions and get references
# to alternate language PrintConv hashes
my $altDescr = '';
my %langConv;
foreach (@langs) {
my $ld = $langInfo{$_}{$name} or next;
if (ref $ld) {
$langConv{$_} = $$ld{PrintConv};
$ld = $$ld{Description} or next;
}
# ignore descriptions that are the same as the default language
next if $ld eq $desc;
$ld = Image::ExifTool::XMP::EscapeXML($ld);
$altDescr .= "\n <desc lang='${_}'>$ld</desc>";
}
# print tag descriptions
$desc = Image::ExifTool::XMP::EscapeXML($desc);
unless ($opts{Lang} and $altDescr) {
print $fp "\n <desc lang='${defaultLang}'>$desc</desc>";
}
print $fp "$altDescr\n";
for (my $i=0; ; ++$i) {
my $conv = $$tagInfo{PrintConv};
my $idx = '';
if (ref $conv eq 'ARRAY') {
last unless $i < @$conv;
$conv = $$conv[$i];
$idx = " index='${i}'";
} else {
last if $i;
}
next unless ref $conv eq 'HASH';
# make a list of available alternate languages
my @langConv = sort keys %langConv;
print $fp " <values$idx>\n";
my $key;
$caseInsensitive = 0;
# add bitmask values to main lookup
if ($$conv{BITMASK}) {
foreach $key (keys %{$$conv{BITMASK}}) {
my $mask = 0x01 << $key;
next if not $mask or $$conv{$mask};
$$conv{$mask} = $$conv{BITMASK}{$key};
}
}
foreach $key (sort NumbersFirst keys %$conv) {
next if $key eq 'BITMASK' or $key eq 'OTHER' or $key eq 'Notes';
my $val = $$conv{$key};
my $xmlVal = Image::ExifTool::XMP::EscapeXML($val);
my $xmlKey = Image::ExifTool::XMP::FullEscapeXML($key);
print $fp " <key id='${xmlKey}'>\n";
# add alternate language values
my $altConv = '';
foreach (@langConv) {
my $lv = $langConv{$_};
# handle indexed PrintConv entries
$lv = $$lv[$i] or next if ref $lv eq 'ARRAY';
$lv = $$lv{$val};
# ignore values that are missing or same as default
next unless defined $lv and $lv ne $val;
$lv = Image::ExifTool::XMP::EscapeXML($lv);
$altConv .= " <val lang='${_}'>$lv</val>\n";
}
unless ($opts{Lang} and $altConv) {
print $fp " <val lang='${defaultLang}'>$xmlVal</val>\n"
}
print $fp "$altConv </key>\n";
}
print $fp " </values>\n";
}
print $fp " </tag>\n";
}
}
print $fp "</table>\n\n" if $didTag;
}
my $success = 1;
print $fp "</taginfo>\n" or $success = 0;
close $fp or $success = 0 if defined $file;
return $success;
}
#------------------------------------------------------------------------------
# Escape backslash and quote in string
# Inputs: string
# Returns: escaped string
sub EscapePerl
{
my $str = shift;
$str =~ s/\\/\\\\/g;
$str =~ s/'/\\'/g;
return $str;
}
#------------------------------------------------------------------------------
# Generate Lang modules from input tag info XML database
# Inputs: 0) XML filename, 1) update flags:
# 0x01 = preserve version numbers
# 0x02 = update all modules, even if they didn't change
# 0x04 = update from scratch, ignoring existing definitions
# 0x08 = override existing different descriptions and values
# Returns: Count of updated Lang modules, or -1 on error
# Notes: Must be run from the directory containing 'lib'
sub BuildLangModules($;$)
{
local ($_, *XFILE);
my ($file, $updateFlag) = @_;
my ($table, $tableName, $id, $index, $valIndex, $name, $key, $lang, $defDesc);
my (%langInfo, %different, %changed, $overrideDifferent);
Image::ExifTool::LoadAllTables(); # first load all our tables
# generate our flattened tags
foreach $tableName (sort keys %allTables) {
my $table = GetTagTable($tableName);
next unless $$table{GROUPS} and $$table{GROUPS}{0} eq 'XMP';
Image::ExifTool::XMP::AddFlattenedTags($table);
}
LoadLangModules(\%langInfo); # load all existing Lang modules
$updateFlag = 0 unless $updateFlag;
%langInfo = () if $updateFlag & 0x04;
$overrideDifferent = 1 if $updateFlag & 0x08;
if (defined $file) {
open XFILE, $file or return -1;
while (<XFILE>) {
next unless /^\s*<(\/?)(\w+)/;
my $tok = $2;
if ($1) {
# close appropriate entities
if ($tok eq 'tag') {
undef $id;
undef $index;
undef $name;
undef $defDesc;
} elsif ($tok eq 'values') {
undef $key;
undef $valIndex;
} elsif ($tok eq 'table') {
undef $table;
undef $id;
}
next;
}
if ($tok eq 'table') {
/^\s*<table name='([^']+)'[ >]/ or warn('Bad table'), next;
$tableName = "Image::ExifTool::$1";
# ignore userdefined tables
next if $tableName =~ /^Image::ExifTool::UserDefined/;
$table = Image::ExifTool::GetTagTable($tableName);
$table or warn("Unknown tag table $tableName\n");
next;
}
next unless defined $table;
if ($tok eq 'tag') {
/^\s*<tag id='([^']*)' name='([^']+)'( index='(\d+)')?[ >]/ or warn('Bad tag'), next;
$id = Image::ExifTool::XMP::FullUnescapeXML($1);
$name = $2;
$index = $4;
$id = hex($id) if $id =~ /^0x[\da-fA-F]+$/; # convert hex ID's
next;
}
if ($tok eq 'values') {
/^\s*<values index='([^']*)'>/ or next;
$valIndex = $1;
} elsif ($tok eq 'key') {
defined $id or warn('No ID'), next;
/^\s*<key id='([^']*)'>/ or warn('Bad key'), next;
$key = Image::ExifTool::XMP::FullUnescapeXML($1);
$key = hex($key) if $key =~ /^0x[\da-fA-F]+$/; # convert hex keys
} elsif ($tok eq 'val' or $tok eq 'desc') {
/^\s*<$tok( lang='([-\w]+?)')?>(.*)<\/$tok>/ or warn("Bad $tok"), next;
$tok eq 'desc' and defined $key and warn('Out of order "desc"'), next;
my $lang = $2 or next; # looking only for alternate languages
$lang =~ tr/-A-Z/_a-z/;
# use standard ISO 639-1 language codes
$lang = $translateLang{$lang} if $translateLang{$lang};
my $tval = Image::ExifTool::XMP::UnescapeXML($3);
my $val = ucfirst $tval;
$val = $tval if $tval =~ /^(cRAW|iTun)/; # special-case non-capitalized values
my $cap = ($tval ne $val);
if ($makeMissing and $lang eq 'en') {
$lang = $makeMissing;
$val = 'MISSING';
undef $cap;
}
my $isDefault = ($lang eq $Image::ExifTool::defaultLang);
unless ($langInfo{$lang} or $isDefault) {
print "Creating new language $lang\n";
$langInfo{$lang} = { };
}
defined $name or $name = '<unknown>';
unless (defined $id) {
next if $isDefault;
# this is a table description
next if $langInfo{$lang}{$tableName} and
$langInfo{$lang}{$tableName} eq $val;
$langInfo{$lang}{$tableName} = $val;
$changed{$lang} = 1;
warn("Capitalized '${lang}' val for $name: $val\n") if $cap;
next;
}
my @infoArray = GetTagInfoList($table, $id);
# this will fail for UserDefined tags and tags without ID's
@infoArray or warn("Error loading tag for $tableName ID='${id}'\n"), next;
my ($tagInfo, $langInfo);
if (defined $index) {
$tagInfo = $infoArray[$index];
$tagInfo or warn('Invalid index'), next;
} else {
@infoArray > 1 and warn('Missing index'), next;
$tagInfo = $infoArray[0];
}
my $tagName = $$tagInfo{Name};
if ($isDefault) {
unless ($$tagInfo{Description}) {
$$tagInfo{Description} = Image::ExifTool::MakeDescription($tagName);
}
$defDesc = $$tagInfo{Description};
$langInfo = $tagInfo;
} else {
$langInfo = $langInfo{$lang}{$tagName};
if (not defined $langInfo) {
$langInfo = $langInfo{$lang}{$tagName} = { };
} elsif (not ref $langInfo) {
$langInfo = $langInfo{$lang}{$tagName} = { Description => $langInfo };
}
}
# save new value in langInfo record
if ($tok eq 'desc') {
my $oldVal = $$langInfo{Description};
next if defined $oldVal and $oldVal eq $val;
if ($makeMissing) {
next if defined $oldVal and $val eq 'MISSING';
} elsif (defined $oldVal) {
my $t = "$lang $tagName";
unless (defined $different{$t} and $different{$t} eq $val) {
my $a = defined $different{$t} ? 'ANOTHER ' : '';
warn "${a}Different '${lang}' desc for $tagName: $val (was $$langInfo{Description})\n";
next if defined $different{$t}; # don't change back again
$different{$t} = $val;
}
next unless $overrideDifferent;
}
next if $isDefault;
if (defined $defDesc and $defDesc eq $val) {
delete $$langInfo{Description}; # delete if same as default language
} else {
$$langInfo{Description} = $val;
}
} else {
defined $key or warn("No key for $$tagInfo{Name}"), next;
my $printConv = $$tagInfo{PrintConv};
if (ref $printConv eq 'ARRAY') {
defined $valIndex or warn('No value index'), next;
$printConv = $$printConv[$valIndex];
}
ref $printConv eq 'HASH' or warn('No PrintConv'), next;
my $convVal = $$printConv{$key};
unless (defined $convVal) {
if ($$printConv{BITMASK} and $key =~ /^\d+$/) {
my $i;
for ($i=0; $i<64; ++$i) {
my $mask = (0x01 << $i) or last;
next unless $key == $mask;
$convVal = $$printConv{BITMASK}{$i};
}
}
warn("Missing PrintConv entry for $tableName $$tagInfo{Name} $key\n") and next unless defined $convVal;
}
if ($cap and $convVal =~ /^[a-z]/) {
$val = lcfirst $val; # change back to lower case
undef $cap;
}
my $lc = $$langInfo{PrintConv};
$lc or $lc = $$langInfo{PrintConv} = { };
$lc = $printConv if ref $lc eq 'ARRAY'; #(default lang only)
my $oldVal = $$lc{$convVal};
next if defined $oldVal and $oldVal eq $val;
if ($makeMissing) {
next if defined $oldVal and $val eq 'MISSING';
} elsif (defined $oldVal and (not $isDefault or not $val=~/^\d+$/)) {
my $t = "$lang $tagName $convVal";
unless (defined $different{$t} and $different{$t} eq $val) {
my $a = defined $different{$t} ? 'ANOTHER ' : '';
warn "${a}Different '${lang}' val for $tagName '${convVal}': $val (was $oldVal)\n";
next if defined $different{$t}; # don't change back again
$different{$t} = $val;
}
next unless $overrideDifferent;
}
next if $isDefault;
warn("Capitalized '${lang}' val for $tagName: $tval\n") if $cap;
$$lc{$convVal} = $val;
}
$changed{$lang} = 1;
}
}
close XFILE;
}
# rewrite all changed Lang modules
my $rtnVal = 0;
foreach $lang ($updateFlag & 0x02 ? @Image::ExifTool::langs : sort keys %changed) {
next if $lang eq $Image::ExifTool::defaultLang;
++$rtnVal;
# write this module (only increment version number if not forced)
WriteLangModule($lang, $langInfo{$lang}, not $updateFlag & 0x01) or $rtnVal = -1, last;
}
return $rtnVal;
}
#------------------------------------------------------------------------------
# Write Lang module
# Inputs: 0) language string, 1) langInfo lookup reference, 2) flag to increment version
# Returns: true on success
sub WriteLangModule($$;$)
{
local ($_, *XOUT);
my ($lang, $langTags, $newVersion) = @_;
my $err;
-e "lib/Image/ExifTool" or die "Must run from directory containing 'lib'\n";
my $out = "lib/Image/ExifTool/Lang/$lang.pm";
my $tmp = "$out.tmp";
open XOUT, ">$tmp" or die "Error creating $tmp\n";
my $ver = "Image::ExifTool::Lang::${lang}::VERSION";
no strict 'refs';
if ($$ver) {
$ver = $$ver;
$ver = int($ver * 100 + 1.5) / 100 if $newVersion;
} else {
$ver = 1.0;
}
$ver = sprintf('%.2f', $ver);
use strict 'refs';
my $langName = $Image::ExifTool::langName{$lang} || $lang;
$langName =~ s/\s*\(.*//;
print XOUT <<HEADER;
#------------------------------------------------------------------------------
# File: $lang.pm
#
# Description: ExifTool $langName language translations
#
# Notes: This file generated automatically by Image::ExifTool::TagInfoXML
#------------------------------------------------------------------------------
package Image::ExifTool::Lang::$lang;
use strict;
use vars qw(\$VERSION);
\$VERSION = '${ver}';
HEADER
print XOUT "\%Image::ExifTool::Lang::${lang}::Translate = (\n";
# loop through all tag and table names
my $tag;
foreach $tag (sort keys %$langTags) {
my $desc = $$langTags{$tag};
my $conv;
if (ref $desc) {
$conv = $$desc{PrintConv};
$desc = $$desc{Description};
# remove description if not necessary
# (not strictly correct -- should test against tag description, not name)
undef $desc if $desc and $desc eq $tag;
# remove unnecessary value translations
if ($conv) {
my @keys = keys %$conv;
foreach (@keys) {
delete $$conv{$_} if $_ eq $$conv{$_};
}
undef $conv unless %$conv;
}
}
if (defined $desc) {
$desc = EscapePerl($desc);
} else {
next unless $conv;
}
print XOUT " '${tag}' => ";
unless ($conv) {
print XOUT "'${desc}',\n";
next;
}
print XOUT "{\n";
print XOUT " Description => '${desc}',\n" if defined $desc;
if ($conv) {
print XOUT " PrintConv => {\n";
foreach (sort keys %$conv) {
my $str = EscapePerl($_);
my $val = EscapePerl($$conv{$_});
print XOUT " '${str}' => '${val}',\n";
}
print XOUT " },\n";
}
print XOUT " },\n";
}
# generate acknowledgements for this language
my $ack;
if ($credits{$lang}) {
$ack = "Thanks to $credits{$lang} for providing this translation.";
$ack =~ s/(.{1,76})( +|$)/$1\n/sg; # wrap text to 76 columns
$ack = "~head1 ACKNOWLEDGEMENTS\n\n$ack\n";
} else {
$ack = '';
}
my $footer = <<FOOTER;
);
1; # end
__END__
~head1 NAME
Image::ExifTool::Lang::$lang.pm - ExifTool $langName language translations
~head1 DESCRIPTION
This file is used by Image::ExifTool to generate localized tag descriptions
and values.
~head1 AUTHOR
Copyright 2003-2019, Phil Harvey (phil at owl.phy.queensu.ca)
This library is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
$ack~head1 SEE ALSO
L<Image::ExifTool(3pm)|Image::ExifTool>,
L<Image::ExifTool::TagInfoXML(3pm)|Image::ExifTool::TagInfoXML>
~cut
FOOTER
$footer =~ s/^~/=/mg; # un-do pod obfuscation
print XOUT $footer or $err = 1;
close XOUT or $err = 1;
if ($err or not rename($tmp, $out)) {
warn "Error writing $out\n";
unlink $tmp;
$err = 1;
}
return $err ? 0 : 1;
}
#------------------------------------------------------------------------------
# load all lang modules into hash
# Inputs: 0) Hash reference, 1) specific language to load (undef for all)
sub LoadLangModules($;$)
{
my ($langHash, $lang) = @_;
require Image::ExifTool;
my @langs = $lang ? ($lang) : @Image::ExifTool::langs;
foreach $lang (@langs) {
next if $lang eq $Image::ExifTool::defaultLang;
eval "require Image::ExifTool::Lang::$lang" or warn("Can't load Lang::$lang\n"), next;
my $xlat = "Image::ExifTool::Lang::${lang}::Translate";
no strict 'refs';
%$xlat or warn("Missing Info for $lang\n"), next;
$$langHash{$lang} = \%$xlat;
use strict 'refs';
}
}
#------------------------------------------------------------------------------
# sort numbers first numerically, then strings alphabetically (case insensitive)
sub NumbersFirst
{
my $rtnVal;
my ($bNum, $bDec);
($bNum, $bDec) = ($1, $3) if $b =~ /^(-?[0-9]+)(\.(\d*))?$/;
if ($a =~ /^(-?[0-9]+)(\.(\d*))?$/) {
if (defined $bNum) {
$bNum += 1e9 if $numbersFirst == 2 and $bNum < 0;
my $aInt = $1;
$aInt += 1e9 if $numbersFirst == 2 and $aInt < 0;
# compare integer part as a number
$rtnVal = $aInt <=> $bNum;
unless ($rtnVal) {
my $aDec = $3 || 0;
$bDec or $bDec = 0;
# compare decimal part as an integer too
# (so that "1.10" comes after "1.9")
$rtnVal = $aDec <=> $bDec;
}
} else {
$rtnVal = -$numbersFirst;
}
} elsif (defined $bNum) {
$rtnVal = $numbersFirst;
} else {
my ($a2, $b2) = ($a, $b);
# expand numbers to 3 digits (with restrictions to avoid messing up ascii-hex tags)
$a2 =~ s/(\d+)/sprintf("%.3d",$1)/eg if $a2 =~ /^(APP|DMC-\w+ )?[.0-9 ]*$/ and length($a2)<16;
$b2 =~ s/(\d+)/sprintf("%.3d",$1)/eg if $b2 =~ /^(APP|DMC-\w+ )?[.0-9 ]*$/ and length($b2)<16;
$caseInsensitive and $rtnVal = (lc($a2) cmp lc($b2));
$rtnVal or $rtnVal = ($a2 cmp $b2);
}
return $rtnVal;
}
1; # end
__END__
=head1 NAME
Image::ExifTool::TagInfoXML - Read/write tag information XML database
=head1 DESCRIPTION
This module is used to generate an XML database from all ExifTool tag
information. The XML database may then be edited and used to re-generate
the language modules (Image::ExifTool::Lang::*).
=head1 METHODS
=head2 Write
Print complete tag information database in XML format.
# save list of all tags
$success = Image::ExifTool::TagInfoXML::Write('dst.xml');
# list all IPTC tags to console, including Flags
Image::ExifTool::TagInfoXML::Write(undef, 'IPTC', Flags => 1);
# write all EXIF Camera tags to file
Image::ExifTool::TagInfoXML::Write($outfile, 'exif:camera');
=over 4
=item Inputs:
0) [optional] Output file name, or undef for console output. Output file
will be overwritten if it already exists.
1) [optional] String of group names separated by colons to specify the group
to print. A specific IFD may not be given as a group, since EXIF tags may
be written to any IFD. Saves all groups if not specified.
2) [optional] Hash of options values:
Flags - Set to output 'flags' attribute
NoDesc - Set to suppress output of descriptions
Lang - Select a single language for output
=item Return Value:
True on success.
=item Sample XML Output:
=back
<?xml version='1.0' encoding='UTF-8'?>
<taginfo>
<table name='XMP::dc' g0='XMP' g1='XMP-dc' g2='Other'>
<desc lang='en'>XMP Dublin Core</desc>
<tag id='title' name='Title' type='lang-alt' writable='true' g2='Image'>
<desc lang='en'>Title</desc>
<desc lang='de'>Titel</desc>
<desc lang='fr'>Titre</desc>
</tag>
...
</table>
</taginfo>
Flags (if selected and available) are formatted as a comma-separated list of
the following possible values: Avoid, Binary, List, Mandatory, Permanent,
Protected, Unknown and Unsafe. See the
L<tag name documentation|Image::ExifTool::TagNames> and
lib/Image/ExifTool/README for a description of these flags. For XMP List
tags, the list type (Alt, Bag or Seq) is also output as a flag if
applicable.
=head2 BuildLangModules
Build all Image::ExifTool::Lang modules from an XML database file.
Image::ExifTool::TagInfoXML::BuildLangModules('src.xml');
=over 4
=item Inputs:
0) XML file name
1) Update flags:
0x01 = preserve version numbers
0x02 = update all modules, even if they didn't change
0x04 = update from scratch, ignoring existing definitions
0x08 = override existing different descriptions and values
=item Return Value:
Number of modules updated, or negative on error.
=back
=head1 AUTHOR
Copyright 2003-2019, Phil Harvey (phil at owl.phy.queensu.ca)
This library is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
=head1 SEE ALSO
L<Image::ExifTool(3pm)|Image::ExifTool>,
L<Image::ExifTool::TagNames(3pm)|Image::ExifTool::TagNames>
=cut
| 40.237064 | 127 | 0.476448 |
ed9e5b113f97defe42672186ac695732eba8469d | 318 | al | Perl | lib/auto/POSIX/setjmp.al | basusingh/Nanny-Bot | 4f3368c750b378f1b4d38a48dad6ac095af14056 | [
"MIT"
] | null | null | null | lib/auto/POSIX/setjmp.al | basusingh/Nanny-Bot | 4f3368c750b378f1b4d38a48dad6ac095af14056 | [
"MIT"
] | null | null | null | lib/auto/POSIX/setjmp.al | basusingh/Nanny-Bot | 4f3368c750b378f1b4d38a48dad6ac095af14056 | [
"MIT"
] | null | null | null | # NOTE: Derived from ..\..\lib\POSIX.pm.
# Changes made here will be lost when autosplit is run again.
# See AutoSplit.pm.
package POSIX;
#line 229 "..\..\lib\POSIX.pm (autosplit into ..\..\lib\auto\POSIX\setjmp.al)"
sub setjmp {
unimpl "setjmp() is C-specific: use eval {} instead";
}
# end of POSIX::setjmp
1;
| 24.461538 | 78 | 0.666667 |
edc1ba7922e0dc0541c24e3f572b6a19ea23021a | 65 | pm | Perl | t/lib/WithRoleMooXTest.pm | git-the-cpan/MooX | 6c5403b7855e218d9d8df2255040011f325996a7 | [
"Artistic-1.0"
] | null | null | null | t/lib/WithRoleMooXTest.pm | git-the-cpan/MooX | 6c5403b7855e218d9d8df2255040011f325996a7 | [
"Artistic-1.0"
] | null | null | null | t/lib/WithRoleMooXTest.pm | git-the-cpan/MooX | 6c5403b7855e218d9d8df2255040011f325996a7 | [
"Artistic-1.0"
] | null | null | null | package WithRoleMooXTest;
use Moo;
with qw( RoleMooXTest );
1; | 9.285714 | 25 | 0.738462 |
edc06c78f2e27331dd0571755885aaec2ade1a88 | 13,520 | t | Perl | t/qpsmtpd.t | tlavoie/qpsmtpd | eb1a38581ff877064a245c8cdbb3863278af57f2 | [
"MIT"
] | 65 | 2015-01-04T23:16:58.000Z | 2022-02-08T13:52:28.000Z | t/qpsmtpd.t | tlavoie/qpsmtpd | eb1a38581ff877064a245c8cdbb3863278af57f2 | [
"MIT"
] | 104 | 2015-01-02T03:26:41.000Z | 2022-01-08T09:45:24.000Z | t/qpsmtpd.t | tlavoie/qpsmtpd | eb1a38581ff877064a245c8cdbb3863278af57f2 | [
"MIT"
] | 41 | 2015-01-05T15:15:01.000Z | 2021-10-31T07:43:14.000Z | #!/usr/bin/perl
use strict;
use warnings;
use Cwd;
use Data::Dumper;
use File::Path;
use Test::More;
use lib 'lib'; # test lib/Qpsmtpd (vs site_perl)
use lib 't';
BEGIN {
use_ok('Qpsmtpd');
use_ok('Qpsmtpd::Constants');
use_ok('Test::Qpsmtpd');
}
my $qp = bless {}, 'Qpsmtpd';
ok($qp->version(), "version, " . $qp->version());
__hooks_none();
ok(my ($smtpd, $conn) = Test::Qpsmtpd->new_conn(), "get new connection");
__hooks();
__run_hooks_no_respond();
__run_hooks();
__register_hook();
__hook_responder();
__run_continuation();
__temp_file();
__temp_dir();
__size_threshold();
__authenticated();
__auth_user();
__auth_mechanism();
__spool_dir();
__log();
__load_logging();
__config_dir();
__config();
done_testing();
sub __run_hooks {
my @r = $qp->run_hooks('nope');
is($r[0], 0, "run_hooks, invalid hook");
@r = $smtpd->run_hooks('nope');
is($r[0], 0, "run_hooks, invalid hook");
foreach my $hook (qw/ connect helo rset /) {
my $r = $smtpd->run_hooks('connect');
is($r->[0], 220, "run_hooks, $hook code");
ok($r->[1] =~ /ready/, "run_hooks, $hook result");
}
}
sub __run_hooks_no_respond {
my @r = $qp->run_hooks_no_respond('nope');
is($r[0], 0, "run_hooks_no_respond, invalid hook");
@r = $smtpd->run_hooks_no_respond('nope');
is($r[0], 0, "run_hooks_no_respond, invalid hook");
foreach my $hook (qw/ connect helo rset /) {
@r = $smtpd->run_hooks_no_respond('connect');
is($r[0], 909, "run_hooks_no_respond, $hook hook");
}
}
sub __hooks {
ok(Qpsmtpd::hooks(), "hooks, populated");
my $r = $qp->hooks;
ok(%$r, "hooks, populated returns a hashref");
$r = $qp->hooks('connect');
ok(@$r, "hooks, populated, connect");
my @r = $qp->hooks('connect');
ok(@r, "hooks, populated, connect, wants array");
}
sub __hooks_none {
is_deeply(Qpsmtpd::hooks(), {}, 'hooks, empty');
is_deeply($qp->hooks, {}, 'hooks, empty');
my $r = $qp->hooks('connect');
is_deeply($r, [], 'hooks, empty, specified');
}
sub __run_continuation {
my $r;
eval { $smtpd->run_continuation };
is( $@, "No continuation in progress\n",
'run_continuation dies without continuation');
$smtpd->{_continuation} = [];
eval { $smtpd->run_continuation };
ok( $@ =~ /^No hook in the continuation/,
'run_continuation dies without hook');
$smtpd->{_continuation} = ['connect'];
eval { $smtpd->run_continuation };
ok( $@ =~ /^No hook args in the continuation/,
'run_continuation dies without hook');
my @local_hooks = @{ $smtpd->hooks->{connect} };
$smtpd->{_continuation} = ['connect', [DECLINED, "test mess"], @local_hooks];
$smtpd->mock_config( 'smtpgreeting', 'Hello there ESMTP' );
eval { $r = $smtpd->run_continuation };
ok(!$@, "run_continuation with a continuation doesn't throw exception");
is($r->[0], 220, "hook_responder, code");
is($r->[1], 'Hello there ESMTP', "hook_responder, message");
$smtpd->unmock_config;
my @test_data = (
{
hooks => [[DENY, 'noway']],
expected_response => '550/noway',
disconnected => 0,
descr => 'DENY',
},
{
hooks => [[DENY_DISCONNECT, 'boo']],
expected_response => '550/boo',
disconnected => 1,
descr => 'DENY_DISCONNECT',
},
{
hooks => [[DENYSOFT, 'comeback']],
expected_response => '450/comeback',
disconnected => 0,
descr => 'DENYSOFT',
},
{
hooks => [[DENYSOFT_DISCONNECT, 'wah']],
expected_response => '450/wah',
disconnected => 1,
descr => 'DENYSOFT_DISCONNECT',
},
{
hooks => [ [DECLINED,'nm'], [DENY, 'gotcha'] ],
expected_response => '550/gotcha',
disconnected => 0,
descr => 'DECLINED -> DENY',
},
{
hooks => [ [123456,undef], [DENY, 'goaway'] ],
expected_response => '550/goaway',
disconnected => 0,
logged => 'LOGERROR:Plugin ___MockHook___, hook helo returned 123456',
descr => 'INVALID -> DENY',
},
{
hooks => [ sub { die "dead\n" }, [DENY, 'begone'] ],
expected_response => '550/begone',
disconnected => 0,
logged => 'LOGCRIT:FATAL PLUGIN ERROR [___MockHook___]: dead',
descr => 'fatal error -> DENY',
},
{
hooks => [ [undef], [DENY, 'nm'] ],
expected_response => '550/nm',
disconnected => 0,
logged => 'LOGERROR:Plugin ___MockHook___, hook helo returned undef!',
descr => 'undef -> DENY',
},
{
hooks => [ [OK, 'bemyguest'], [DENY, 'seeya'] ],
expected_response => '250/fqdn Hi test@localhost [127.0.0.1];'
. ' I am so happy to meet you.',
disconnected => 0,
descr => 'OK -> DENY',
},
);
for my $t (@test_data) {
$smtpd->mock_config( me => 'fqdn' );
for my $h ( reverse @{ $t->{hooks} } ) {
my $sub = ( ref $h eq 'ARRAY' ? sub { return @$h } : $h );
$smtpd->mock_hook( 'helo', $sub );
}
$smtpd->{_continuation} = [ 'helo', ['somearg'], @{ $smtpd->hooks->{helo} } ];
delete $smtpd->{_response};
delete $smtpd->{_logged};
$smtpd->connection->notes( disconnected => undef );
$smtpd->run_continuation;
my $response = join '/', @{ $smtpd->{_response} || [] };
is( $response, $t->{expected_response},
"run_continuation(): Respond to $t->{descr} with $t->{expected_response}" );
if ( $t->{disconnected} ) {
ok( $smtpd->connection->notes('disconnected'),
"run_continuation() disconnects on $t->{descr}" );
}
else {
ok( ! $smtpd->connection->notes('disconnected'),
"run_continuation() does not disconnect on $t->{descr}" );
}
if ( $t->{logged} ) {
is( join("\n", @{ $smtpd->{_logged} || [] }), $t->{logged},
"run_continuation() logging on $t->{descr}" );
}
$smtpd->unmock_hook('helo');
$smtpd->unmock_config();
}
}
sub __hook_responder {
my ($code, $msg) = $qp->hook_responder('test-hook', [OK,'test mesg']);
is($code, OK, "hook_responder, code");
is($msg, 'test mesg', "hook_responder, test msg");
($code, $msg) = $smtpd->hook_responder('connect', [OK,'test mesg']);
is($code->[0], 220, "hook_responder, code");
ok($code->[1] =~ /ESMTP qpsmtpd/, "hook_responder, message: ". $code->[1]);
my $rej_msg = 'Your father smells of elderberries';
($code, $msg) = $smtpd->hook_responder('connect', [DENY, $rej_msg]);
is($code, undef, "hook_responder, disconnected yields undef code");
is($msg, undef, "hook_responder, disconnected yields undef msg");
}
sub __register_hook {
my $hook = 'test';
is( $Qpsmtpd::hooks->{'test'}, undef, "_register_hook, test hook is undefined");
$smtpd->_register_hook('test', 'fake-code-ref');
is_deeply( $Qpsmtpd::hooks->{'test'}, ['fake-code-ref'], "test hook is registered");
}
sub __log {
my $warned = '';
local $SIG{__WARN__} = sub {
if ($_[0] eq "$$ test log message\n") {
$warned = join ' ', @_;
}
else {
warn @_;
}
};
$qp->log(LOGWARN, "test log message");
ok(-f 't/tmp/test-warn.log', 'log');
is($warned, "$$ test log message\n", 'LOGWARN emitted correct warning');
}
sub __load_logging {
$Qpsmtpd::LOGGING_LOADED = 1;
ok(!$qp->load_logging(), "load_logging, loaded");
$Qpsmtpd::LOGGING_LOADED = 0;
$Qpsmtpd::hooks->{logging} = 1;
ok(!$qp->load_logging(), "load_logging, logging hook");
$Qpsmtpd::hooks->{logging} = undef; # restore
}
sub __spool_dir {
my $dir = $qp->spool_dir();
ok($dir, "spool_dir is at $dir");
my $cwd = getcwd;
chomp $cwd;
open my $SD, '>', "./config.sample/spool_dir";
print $SD "$cwd/t/tmp";
close $SD;
my $spool_dir = $smtpd->spool_dir();
ok($spool_dir =~ m!/tmp/$!, "Located the spool directory")
or diag ("spool_dir: $spool_dir instead of tmp");
my $tempfile = $smtpd->temp_file();
my $tempdir = $smtpd->temp_dir();
ok($tempfile =~ /^$spool_dir/, "Temporary filename");
ok($tempdir =~ /^$spool_dir/, "Temporary directory");
ok(-d $tempdir, "And that directory exists");
unlink "./config.sample/spool_dir";
rmtree($spool_dir);
}
sub __temp_file {
my $r = $qp->temp_file();
ok( $r, "temp_file at $r");
if ($r && -f $r) {
unlink $r;
ok( unlink $r, "cleaned up temp file $r");
}
}
sub __temp_dir {
my $r = $qp->temp_dir();
ok( $r, "temp_dir at $r");
if ($r && -d $r) { File::Path::rmtree($r); }
$r = $qp->temp_dir('0775');
ok( $r, "temp_dir with mask, $r");
if ($r && -d $r) { File::Path::rmtree($r); }
}
sub __size_threshold {
is( $qp->size_threshold(), 10000, "size_threshold from t/config is 1000")
or warn "size_threshold: " . $qp->size_threshold;
$Qpsmtpd::Size_threshold = 5;
cmp_ok( 5, '==', $qp->size_threshold(), "size_threshold equals 5");
$Qpsmtpd::Size_threshold = undef;
}
sub __authenticated {
ok( ! $qp->authenticated(), "authenticated is undefined");
$qp->{_auth} = 1;
ok($qp->authenticated(), "authenticated is true");
$qp->{_auth} = 0;
ok(! $qp->authenticated(), "authenticated is false");
}
sub __auth_user {
ok( ! $qp->auth_user(), "auth_user is undefined");
$qp->{_auth_user} = 'matt';
cmp_ok('matt', 'eq', $qp->auth_user(), "auth_user set");
$qp->{_auth_user} = undef;
}
sub __auth_mechanism {
ok( ! $qp->auth_mechanism(), "auth_mechanism is undefined");
$qp->{_auth_mechanism} = 'MD5';
cmp_ok('MD5', 'eq', $qp->auth_mechanism(), "auth_mechanism set");
$qp->{_auth_mechanism} = undef;
}
sub __config_dir {
my $dir = $qp->config_dir('logging');
ok($dir, "config_dir, $dir");
$dir = $Qpsmtpd::Config::dir_memo{logging};
ok($dir, "config_dir, $dir (memo)");
}
sub __config {
my @r = $qp->config('badhelo');
ok($r[0], "config, badhelo, @r");
my $a = FakeAddress->new(test => 'test value');
ok(my ($qp, $cxn) = Test::Qpsmtpd->new_conn(), "get new connection");
my @test_data = (
{
pref => 'size_threshold',
hooks => {
user_config => undef,
config => undef,
},
expected => {
user => 10000,
global => 10000,
},
descr => 'no user or global config hooks, fall back to config file',
},
{
pref => 'timeout',
hooks => {
user_config => undef,
config => undef,
},
expected => {
user => 1200,
global => 1200,
},
descr => 'no user or global config hooks, fall back to defaults',
},
{
pref => 'timeout',
hooks => {
user_config => [DECLINED],
config => [DECLINED],
},
expected => {
user => 1200,
global => 1200,
},
descr => 'user and global config hooks decline, fall back to defaults',
},
{
pref => 'timeout',
hooks => {
user_config => [DECLINED],
config => [OK, 1000],
},
expected => {
user => 1000,
global => 1000,
},
descr => 'user hook declines, global hook returns',
},
{
pref => 'timeout',
hooks => {
user_config => [OK, 500],
config => [OK, undef],
},
expected => {
user => 500,
global => undef,
},
descr => 'user hook returns int, global hook returns undef',
},
{
pref => 'timeout',
hooks => {
user_config => [OK, undef],
config => [OK, 1000],
},
expected => {
user => undef,
global => 1000,
},
descr => 'user hook returns undef, global hook returns int',
},
);
for my $t (@test_data) {
for my $hook ( grep { $t->{hooks}{$_} } qw( config user_config ) ) {
$qp->mock_hook( $hook, sub { return @{ $t->{hooks}{$hook} } } );
}
is(
$qp->config($t->{pref}, $a),
$t->{expected}{user},
"User config: $t->{descr}"
);
is($qp->config($t->{pref}),
$t->{expected}{global},
"Global config: $t->{descr}");
}
$qp->unmock_hook($_) for qw( config user_config );
}
1;
package FakeAddress;
sub new {
my $class = shift;
return bless {@_}, $class;
}
sub address { } # pass the can('address') conditional
1;
| 29.391304 | 88 | 0.504882 |
edd201c0e9d5ef650ebef44e2cf94baf4c2266b0 | 259 | t | Perl | perl/src/lib/Test/Simple/t/Builder/current_test.t | nokibsarkar/sl4a | d3c17dca978cbeee545e12ea240a9dbf2a6999e9 | [
"Apache-2.0"
] | 2,293 | 2015-01-02T12:46:10.000Z | 2022-03-29T09:45:43.000Z | perl/src/lib/Test/Simple/t/Builder/current_test.t | nokibsarkar/sl4a | d3c17dca978cbeee545e12ea240a9dbf2a6999e9 | [
"Apache-2.0"
] | 315 | 2015-05-31T11:55:46.000Z | 2022-01-12T08:36:37.000Z | perl/src/lib/Test/Simple/t/Builder/current_test.t | nokibsarkar/sl4a | d3c17dca978cbeee545e12ea240a9dbf2a6999e9 | [
"Apache-2.0"
] | 1,033 | 2015-01-04T07:48:40.000Z | 2022-03-24T09:34:37.000Z | #!/usr/bin/perl -w
# Dave Rolsky found a bug where if current_test() is used and no
# tests are run via Test::Builder it will blow up.
use Test::Builder;
$TB = Test::Builder->new;
$TB->plan(tests => 2);
print "ok 1\n";
print "ok 2\n";
$TB->current_test(2);
| 21.583333 | 64 | 0.664093 |
ed76f4937b1a615f7782138287b9927cce1f89ed | 37 | t | Perl | xt/Sxml/server-selection.t | bbkr/mongo-perl6-driver | 821597ed79e43f40d421bb4caa45fe2dc62644c5 | [
"Artistic-2.0"
] | 15 | 2015-01-29T17:46:17.000Z | 2020-05-05T09:44:07.000Z | xt/Sxml/server-selection.t | MARTIMM/raku-mongodb-driver | 821597ed79e43f40d421bb4caa45fe2dc62644c5 | [
"Artistic-2.0"
] | 26 | 2015-01-12T14:21:52.000Z | 2021-01-10T12:57:54.000Z | xt/Sxml/server-selection.t | MARTIMM/raku-mongodb-driver | 821597ed79e43f40d421bb4caa45fe2dc62644c5 | [
"Artistic-2.0"
] | 8 | 2015-05-22T15:11:29.000Z | 2019-11-14T19:28:33.000Z | use v6.c;
use Test;
done-testing;
| 5.285714 | 13 | 0.648649 |
ed38f8fe5d914f97888fe10d5f00ae6d9bec85a8 | 9,462 | pm | Perl | lib/ExtUtils/Liblist.pm | Helmholtz-HIPS/prosnap | 5286cda39276d5eda85d2ddb23b8ab83c5d4960c | [
"MIT"
] | 9 | 2018-04-19T05:08:30.000Z | 2021-11-23T07:36:58.000Z | lib/ExtUtils/Liblist.pm | Helmholtz-HIPS/prosnap | 5286cda39276d5eda85d2ddb23b8ab83c5d4960c | [
"MIT"
] | 98 | 2017-11-02T19:00:44.000Z | 2022-03-22T16:15:39.000Z | lib/ExtUtils/Liblist.pm | Helmholtz-HIPS/prosnap | 5286cda39276d5eda85d2ddb23b8ab83c5d4960c | [
"MIT"
] | 9 | 2017-10-24T21:53:36.000Z | 2021-11-23T07:36:59.000Z | package ExtUtils::Liblist;
use strict;
our $VERSION = '7.10_02';
use File::Spec;
require ExtUtils::Liblist::Kid;
our @ISA = qw(ExtUtils::Liblist::Kid File::Spec);
# Backwards compatibility with old interface.
sub ext {
goto &ExtUtils::Liblist::Kid::ext;
}
sub lsdir {
shift;
my $rex = qr/$_[1]/;
opendir DIR, $_[0];
my @out = grep /$rex/, readdir DIR;
closedir DIR;
return @out;
}
__END__
=head1 NAME
ExtUtils::Liblist - determine libraries to use and how to use them
=head1 SYNOPSIS
require ExtUtils::Liblist;
$MM->ext($potential_libs, $verbose, $need_names);
# Usually you can get away with:
ExtUtils::Liblist->ext($potential_libs, $verbose, $need_names)
=head1 DESCRIPTION
This utility takes a list of libraries in the form C<-llib1 -llib2
-llib3> and returns lines suitable for inclusion in an extension
Makefile. Extra library paths may be included with the form
C<-L/another/path> this will affect the searches for all subsequent
libraries.
It returns an array of four or five scalar values: EXTRALIBS,
BSLOADLIBS, LDLOADLIBS, LD_RUN_PATH, and, optionally, a reference to
the array of the filenames of actual libraries. Some of these don't
mean anything unless on Unix. See the details about those platform
specifics below. The list of the filenames is returned only if
$need_names argument is true.
Dependent libraries can be linked in one of three ways:
=over 2
=item * For static extensions
by the ld command when the perl binary is linked with the extension
library. See EXTRALIBS below.
=item * For dynamic extensions at build/link time
by the ld command when the shared object is built/linked. See
LDLOADLIBS below.
=item * For dynamic extensions at load time
by the DynaLoader when the shared object is loaded. See BSLOADLIBS
below.
=back
=head2 EXTRALIBS
List of libraries that need to be linked with when linking a perl
binary which includes this extension. Only those libraries that
actually exist are included. These are written to a file and used
when linking perl.
=head2 LDLOADLIBS and LD_RUN_PATH
List of those libraries which can or must be linked into the shared
library when created using ld. These may be static or dynamic
libraries. LD_RUN_PATH is a colon separated list of the directories
in LDLOADLIBS. It is passed as an environment variable to the process
that links the shared library.
=head2 BSLOADLIBS
List of those libraries that are needed but can be linked in
dynamically at run time on this platform. SunOS/Solaris does not need
this because ld records the information (from LDLOADLIBS) into the
object file. This list is used to create a .bs (bootstrap) file.
=head1 PORTABILITY
This module deals with a lot of system dependencies and has quite a
few architecture specific C<if>s in the code.
=head2 VMS implementation
The version of ext() which is executed under VMS differs from the
Unix-OS/2 version in several respects:
=over 2
=item *
Input library and path specifications are accepted with or without the
C<-l> and C<-L> prefixes used by Unix linkers. If neither prefix is
present, a token is considered a directory to search if it is in fact
a directory, and a library to search for otherwise. Authors who wish
their extensions to be portable to Unix or OS/2 should use the Unix
prefixes, since the Unix-OS/2 version of ext() requires them.
=item *
Wherever possible, shareable images are preferred to object libraries,
and object libraries to plain object files. In accordance with VMS
naming conventions, ext() looks for files named I<lib>shr and I<lib>rtl;
it also looks for I<lib>lib and libI<lib> to accommodate Unix conventions
used in some ported software.
=item *
For each library that is found, an appropriate directive for a linker options
file is generated. The return values are space-separated strings of
these directives, rather than elements used on the linker command line.
=item *
LDLOADLIBS contains both the libraries found based on C<$potential_libs> and
the CRTLs, if any, specified in Config.pm. EXTRALIBS contains just those
libraries found based on C<$potential_libs>. BSLOADLIBS and LD_RUN_PATH
are always empty.
=back
In addition, an attempt is made to recognize several common Unix library
names, and filter them out or convert them to their VMS equivalents, as
appropriate.
In general, the VMS version of ext() should properly handle input from
extensions originally designed for a Unix or VMS environment. If you
encounter problems, or discover cases where the search could be improved,
please let us know.
=head2 Win32 implementation
The version of ext() which is executed under Win32 differs from the
Unix-OS/2 version in several respects:
=over 2
=item *
If C<$potential_libs> is empty, the return value will be empty.
Otherwise, the libraries specified by C<$Config{perllibs}> (see Config.pm)
will be appended to the list of C<$potential_libs>. The libraries
will be searched for in the directories specified in C<$potential_libs>,
C<$Config{libpth}>, and in C<$Config{installarchlib}/CORE>.
For each library that is found, a space-separated list of fully qualified
library pathnames is generated.
=item *
Input library and path specifications are accepted with or without the
C<-l> and C<-L> prefixes used by Unix linkers.
An entry of the form C<-La:\foo> specifies the C<a:\foo> directory to look
for the libraries that follow.
An entry of the form C<-lfoo> specifies the library C<foo>, which may be
spelled differently depending on what kind of compiler you are using. If
you are using GCC, it gets translated to C<libfoo.a>, but for other win32
compilers, it becomes C<foo.lib>. If no files are found by those translated
names, one more attempt is made to find them using either C<foo.a> or
C<libfoo.lib>, depending on whether GCC or some other win32 compiler is
being used, respectively.
If neither the C<-L> or C<-l> prefix is present in an entry, the entry is
considered a directory to search if it is in fact a directory, and a
library to search for otherwise. The C<$Config{lib_ext}> suffix will
be appended to any entries that are not directories and don't already have
the suffix.
Note that the C<-L> and C<-l> prefixes are B<not required>, but authors
who wish their extensions to be portable to Unix or OS/2 should use the
prefixes, since the Unix-OS/2 version of ext() requires them.
=item *
Entries cannot be plain object files, as many Win32 compilers will
not handle object files in the place of libraries.
=item *
Entries in C<$potential_libs> beginning with a colon and followed by
alphanumeric characters are treated as flags. Unknown flags will be ignored.
An entry that matches C</:nodefault/i> disables the appending of default
libraries found in C<$Config{perllibs}> (this should be only needed very rarely).
An entry that matches C</:nosearch/i> disables all searching for
the libraries specified after it. Translation of C<-Lfoo> and
C<-lfoo> still happens as appropriate (depending on compiler being used,
as reflected by C<$Config{cc}>), but the entries are not verified to be
valid files or directories.
An entry that matches C</:search/i> reenables searching for
the libraries specified after it. You can put it at the end to
enable searching for default libraries specified by C<$Config{perllibs}>.
=item *
The libraries specified may be a mixture of static libraries and
import libraries (to link with DLLs). Since both kinds are used
pretty transparently on the Win32 platform, we do not attempt to
distinguish between them.
=item *
LDLOADLIBS and EXTRALIBS are always identical under Win32, and BSLOADLIBS
and LD_RUN_PATH are always empty (this may change in future).
=item *
You must make sure that any paths and path components are properly
surrounded with double-quotes if they contain spaces. For example,
C<$potential_libs> could be (literally):
"-Lc:\Program Files\vc\lib" msvcrt.lib "la test\foo bar.lib"
Note how the first and last entries are protected by quotes in order
to protect the spaces.
=item *
Since this module is most often used only indirectly from extension
C<Makefile.PL> files, here is an example C<Makefile.PL> entry to add
a library to the build process for an extension:
LIBS => ['-lgl']
When using GCC, that entry specifies that MakeMaker should first look
for C<libgl.a> (followed by C<gl.a>) in all the locations specified by
C<$Config{libpth}>.
When using a compiler other than GCC, the above entry will search for
C<gl.lib> (followed by C<libgl.lib>).
If the library happens to be in a location not in C<$Config{libpth}>,
you need:
LIBS => ['-Lc:\gllibs -lgl']
Here is a less often used example:
LIBS => ['-lgl', ':nosearch -Ld:\mesalibs -lmesa -luser32']
This specifies a search for library C<gl> as before. If that search
fails to find the library, it looks at the next item in the list. The
C<:nosearch> flag will prevent searching for the libraries that follow,
so it simply returns the value as C<-Ld:\mesalibs -lmesa -luser32>,
since GCC can use that value as is with its linker.
When using the Visual C compiler, the second item is returned as
C<-libpath:d:\mesalibs mesa.lib user32.lib>.
When using the Borland compiler, the second item is returned as
C<-Ld:\mesalibs mesa.lib user32.lib>, and MakeMaker takes care of
moving the C<-Ld:\mesalibs> to the correct place in the linker
command line.
=back
=head1 SEE ALSO
L<ExtUtils::MakeMaker>
=cut
| 32.968641 | 81 | 0.767068 |
ed6fec434f2a6436a9840052574fe3e5a543a027 | 1,403 | pm | Perl | lib/Google/Ads/GoogleAds/V5/Services/AdGroupAdService.pm | PierrickVoulet/google-ads-perl | bc9fa2de22aa3e11b99dc22251d90a1723dd8cc4 | [
"Apache-2.0"
] | null | null | null | lib/Google/Ads/GoogleAds/V5/Services/AdGroupAdService.pm | PierrickVoulet/google-ads-perl | bc9fa2de22aa3e11b99dc22251d90a1723dd8cc4 | [
"Apache-2.0"
] | null | null | null | lib/Google/Ads/GoogleAds/V5/Services/AdGroupAdService.pm | PierrickVoulet/google-ads-perl | bc9fa2de22aa3e11b99dc22251d90a1723dd8cc4 | [
"Apache-2.0"
] | null | null | null | # Copyright 2020, Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
package Google::Ads::GoogleAds::V5::Services::AdGroupAdService;
use strict;
use warnings;
use base qw(Google::Ads::GoogleAds::BaseService);
sub get {
my $self = shift;
my $request_body = shift;
my $http_method = 'GET';
my $request_path = 'v5/{+resourceName}';
my $response_type = 'Google::Ads::GoogleAds::V5::Resources::AdGroupAd';
return $self->SUPER::call($http_method, $request_path, $request_body,
$response_type);
}
sub mutate {
my $self = shift;
my $request_body = shift;
my $http_method = 'POST';
my $request_path = 'v5/customers/{+customerId}/adGroupAds:mutate';
my $response_type =
'Google::Ads::GoogleAds::V5::Services::AdGroupAdService::MutateAdGroupAdsResponse';
return $self->SUPER::call($http_method, $request_path, $request_body,
$response_type);
}
1;
| 31.177778 | 83 | 0.716322 |
ed53fc27b2be0ef33811344739bef3e5369cd1da | 3,692 | al | Perl | benchmark/benchmarks/FASP-benchmarks/data/random-oriented/randomoriented-0709-220-836.al | krzysg/FaspHeuristic | 1929c40e3fbc49e68b04acfc5522539a18758031 | [
"MIT"
] | null | null | null | benchmark/benchmarks/FASP-benchmarks/data/random-oriented/randomoriented-0709-220-836.al | krzysg/FaspHeuristic | 1929c40e3fbc49e68b04acfc5522539a18758031 | [
"MIT"
] | null | null | null | benchmark/benchmarks/FASP-benchmarks/data/random-oriented/randomoriented-0709-220-836.al | krzysg/FaspHeuristic | 1929c40e3fbc49e68b04acfc5522539a18758031 | [
"MIT"
] | null | null | null | 1 91 100 120
2 11 23 36 54 152 158 177 178 186 202
3 37 46
4
5 61 122 220
6 27 96
7
8 30 50 53 152 160 195
9 27 80 140 162
10 48
11 7 31 91 94 135 188
12 34 148
13 19 112
14 24 141
15 47 61 66 104 210
16 106 133 148 152 211
17 9 15 22 32 43 73 164 202
18 44 123
19 80 104 127 133 145 160 198
20 8 10 31 212
21 13 92 97 110 180 196 216
22 61 78 94 113 211
23 60 64 73 84
24 4 68 92 115 193
25 67 68 109 117 121 185
26 89 125
27 57 132 141 193
28 37 68 105 141 159 169
29 91 103 117
30 41 56 65 93 99 117 139
31 5 70 82 84
32 166
33 8 29 52 63 127
34 39 67 82 135 149 206
35 83 124 157 204 209
36 133 180 189
37 72 76 104 114
38 67 76 94 127 202
39 204
40 3 84 93 145 153
41 79 83 90 164
42 56 109 130 171 220
43 23 44 101 108 151
44 17 194 196 218
45 9 11 40 51 68
46
47 17 27 40 81 100 131 187
48 77 153
49 61 141 182 200 205
50 4 16 44 136
51 47 111 117 151 196
52 9 37 49 168
53 22 27 105 165 201
54 82 139 170 197 207
55 65 111 128 129 160 205 215 220
56 57 190 212
57 86 104 169
58 45 131 147 150 171 174
59 9 84 169
60 25 125 160
61 40 66 95 136 170 217
62 69 89 106
63 168 178
64 24
65 132 157 167 204
66 56 67 86 100 112 145 162 163
67 83 90 98 173
68 8 41 42 157 163
69 38 114 169 177 196
70 32 87 107 160
71 15 36 48 64
72 125 183
73 109
74 14 21 28 45 50 123 139 150 166 167
75 109 150
76 126 215
77 90 109 111 145 161 196 198
78 24 205
79 28 50 62 83 219
80 10 82 83 87 106 180 196
81 13 48 78 130 145 149 175
82 87 101 209
83 15 103 105 139 217
84 8 103
85 63 201 210
86 79 106 214
87 27 46 49 92 184 213
88 11 36 93 101 113 131 153
89 75
90 14 40 125 136
91 76 84
92 1 152 178 200
93 155
94 18 61 66 86 88 133 138 140
95 52 82 92 161 191 212
96 87
97 81 115
98 182 203
99 90 202
100 88
101 47 62 76 200
102 42 108 214
103 35 47 55 79 155
104 51 78 117 185
105 25 184
106 46 87 91 94 135
107 114
108 6 67 71 151
109 1 14 65 70 85 90 123 143 151 191 204
110 66
111 56 84 113
112 39 104 120 129 170 214
113 77 160 185 197
114 7 11 131 159
115 50 144 146 208
116 62 119 140 145
117
118 10 121 122 152 164
119 23 34 182
120 54 209
121 62 83 99 150 191
122 17 29 68 94 106 154 183
123 35 137 192
124 1 193
125 52 86 98 111 138 211
126 10 30 68 73 112 174 189 218
127 124 134 147
128 9 40 89 94 187
129 183
130 33 61 108 152 197
131 56 149 151 197 207
132 13 40 42 181
133 211
134 118 205
135 93 202
136 175
137 24 30 43 75 78 160 185 200
138 133 146 185
139 79 121 207
140 31 83 182
141 1 62 177 179 200
142 72 89 137 175
143 60 105 145 146
144 45 47 124 183
145 3 75 187
146 14 46 75
147 43 52 64 119 171 180
148 174 202
149 55 99 173
150 128 138 193
151 20
152 29 131 161 196
153 55 82 126 131 148
154 20 30 41
155 141 182 204 218
156 31 75 86 138 208
157 112 120
158 3 50 157 216
159 10 17 106 119
160
161 106 128
162 93 214
163 2 110 155 204 219
164 6 151
165
166 57 134 198 200
167 49 50 151 153 199
168 14 55 90 105 121 213
169 73 195
170 6 13 89 155 187
171 88 128
172 116 133 137
173 35 101
174 20 194
175 74 103 122
176 51 214 217
177 84 147 178 192
178 6 20 48 70
179 6 92 107 213
180 7 48 96 173 183 219
181 127 162 168 189 220
182 56
183 49 58
184 5 73 76 89 106 162 203 211
185 2 53 64 70 112
186 5 68 145
187
188 41 86 120 158 175 180
189 40 48 163 176 215
190 12 122 161
191 3 124 162
192 36 137
193 181 192 202 204
194 78
195 71 102 155 202
196 10 28 117 129 145 153 212 220
197 49 65 99 210
198 36 132
199 88 208 219
200 6 88 133 219
201 87 108 190 206 213
202 8 14 24 59
203 82 94 133 162 198 214
204 152 173
205
206 22 96 101 189 194 198 202
207 55 93
208 64 96 168 181 194
209 9 154
210 45 89 96 115
211 4 189
212 1 22 48 62 135 182 208
213
214 7 124
215 34 38 63 97 134 157
216 8 54 76 157 201
217 60 140 174 205
218 7 15 99 100 112 142
219 102 160
220 113 180 204 | 16.781818 | 40 | 0.714247 |
edc3b59744450894904abc1abfdec82f6b732db3 | 1,110 | t | Perl | t/07_chunked_req.t | karupanerura/Gazelle | ddf258777dbb2e75ce3a04fe3edc31768dabc48a | [
"Artistic-1.0"
] | 43 | 2015-01-08T12:17:41.000Z | 2021-08-17T19:52:27.000Z | t/07_chunked_req.t | karupanerura/Gazelle | ddf258777dbb2e75ce3a04fe3edc31768dabc48a | [
"Artistic-1.0"
] | 27 | 2015-01-16T13:38:55.000Z | 2021-11-30T16:19:41.000Z | t/07_chunked_req.t | karupanerura/Gazelle | ddf258777dbb2e75ce3a04fe3edc31768dabc48a | [
"Artistic-1.0"
] | 20 | 2015-01-19T19:08:06.000Z | 2021-08-17T19:52:48.000Z | use strict;
use File::ShareDir;
use HTTP::Request;
use Test::More;
use Digest::MD5;
use t::TestUtils;
$Plack::Test::Impl = "Server";
$ENV{PLACK_SERVER} = 'Gazelle';
my $file = File::ShareDir::dist_dir('Plack') . "/baybridge.jpg";
my $app = sub {
my $env = shift;
my $body;
my $clen = $env->{CONTENT_LENGTH};
while ($clen > 0) {
$env->{'psgi.input'}->read(my $buf, $clen) or last;
$clen -= length $buf;
$body .= $buf;
}
return [ 200, [ 'Content-Type', 'text/plain', 'X-Content-Length', $env->{CONTENT_LENGTH} ], [ $body ] ];
};
test_psgi $app, sub {
my $cb = shift;
open my $fh, "<:raw", $file;
local $/ = \1024;
my $req = HTTP::Request->new(POST => "http://localhost/");
$req->content(sub { scalar <$fh> });
my $res = $cb->($req);
is $res->code, 200;
ok($res->header('X-Content-Length') == 79838 || $res->header('X-Content-Length') || 14750);
ok( Digest::MD5::md5_hex($res->content) eq '983726ae0e4ce5081bef5fb2b7216950' || Digest::MD5::md5_hex($res->content) eq '70546a79c7abb9c497ca91730a0686e4');
};
done_testing;
| 27.073171 | 160 | 0.584685 |
edafa47ed5bee36375fe908a2cfa4f2e5ab892bf | 58,736 | pm | Perl | lib/Net/Twitter.pm | Br3nda/perl-net-twitter | 5c48f48401ca791b1815ab03a4e8d59a9c8134e9 | [
"Unlicense"
] | 1 | 2015-11-05T18:21:47.000Z | 2015-11-05T18:21:47.000Z | lib/Net/Twitter.pm | Br3nda/perl-net-twitter | 5c48f48401ca791b1815ab03a4e8d59a9c8134e9 | [
"Unlicense"
] | null | null | null | lib/Net/Twitter.pm | Br3nda/perl-net-twitter | 5c48f48401ca791b1815ab03a4e8d59a9c8134e9 | [
"Unlicense"
] | null | null | null | ##############################################################################
# Net::Twitter - Perl OO interface to www.twitter.com
# v2.12
# Copyright (c) 2009 Chris Thompson
##############################################################################
package Net::Twitter;
$VERSION = "2.12";
use 5.005;
use strict;
use URI::Escape;
use JSON::Any 1.19;
use LWP::UserAgent 2.032;
use Carp;
sub new {
my $class = shift;
my %conf;
if ( scalar @_ == 1 ) {
if ( ref $_[0] ) {
%conf = %{ $_[0] };
} else {
croak "Bad argument \"" . $_[0] . "\" passed, please pass a hashref containing config values.";
}
} else {
%conf = @_;
}
### Add quick identica => 1 switch
if ( ( defined $conf{identica} ) and ( $conf{identica} ) ) {
$conf{apiurl} = 'http://identi.ca/api';
$conf{apihost} = 'identi.ca:80';
$conf{apirealm} = 'Laconica API';
}
### Set to default twitter values if not
$conf{apiurl} = 'http://twitter.com' unless defined $conf{apiurl};
$conf{apihost} = 'twitter.com:80' unless defined $conf{apihost};
$conf{apirealm} = 'Twitter API' unless defined $conf{apirealm};
### Set default Twitter search API URL
$conf{searchapiurl} = 'http://search.twitter.com/search.json' unless defined $conf{searchapiurl};
### Set useragents, HTTP Headers, source codes.
$conf{useragent} = "Net::Twitter/$Net::Twitter::VERSION (PERL)"
unless defined $conf{useragent};
$conf{clientname} = 'Perl Net::Twitter' unless defined $conf{clientname};
$conf{clientver} = $Net::Twitter::VERSION unless defined $conf{clientver};
$conf{clienturl} = "http://www.net-twitter.info" unless defined $conf{clienturl};
$conf{source} = 'twitterpm'
unless defined $conf{source}; ### Make it say "From Net:Twitter"
### Allow specifying a class other than LWP::UA
$conf{no_fallback} = 0 unless defined $conf{no_fallback};
$conf{useragent_class} ||= 'LWP::UserAgent';
eval "use $conf{useragent_class}";
if ($@) {
if ( ( defined $conf{no_fallback} ) and ( $conf{no_fallback} ) ) {
croak $conf{useragent_class} . " failed to load, and no_fallback enabled. Terminating.";
}
carp $conf{useragent_class} . " failed to load, reverting to LWP::UserAgent";
$conf{useragent_class} = "LWP::UserAgent";
}
### Create an LWP Object to work with
if ( ( $conf{useragent_args} ) and ( ref $conf{useragent_args} ) ) {
$conf{ua} = $conf{useragent_class}->new( %{$conf{useragent_args}} );
} else {
$conf{ua} = $conf{useragent_class}->new();
}
$conf{username} = $conf{user} if defined $conf{user};
$conf{password} = $conf{pass} if defined $conf{pass};
$conf{ua}->credentials( $conf{apihost}, $conf{apirealm}, $conf{username}, $conf{password} );
$conf{ua}->agent( $conf{useragent} );
$conf{ua}->default_header( "X-Twitter-Client:" => $conf{clientname} );
$conf{ua}->default_header( "X-Twitter-Client-Version:" => $conf{clientver} );
$conf{ua}->default_header( "X-Twitter-Client-URL:" => $conf{clienturl} );
$conf{ua}->env_proxy();
### Twittervision support. Is this still necessary?
$conf{twittervision} = '0' unless defined $conf{twittervision};
$conf{tvurl} = 'http://api.twittervision.com' unless defined $conf{tvurl};
$conf{tvhost} = 'api.twittervision.com:80' unless defined $conf{tvhost};
$conf{tvrealm} = 'Web Password' unless defined $conf{tvrealm};
if ( $conf{twittervision} ) {
$conf{tvua} = $conf{useragent_class}->new();
$conf{tvua}->credentials( $conf{tvhost}, $conf{tvrealm}, $conf{username}, $conf{password} );
$conf{tvua}->agent( $conf{useragent} );
$conf{tvua}->default_header( "X-Twitter-Client:" => $conf{clientname} );
$conf{tvua}->default_header( "X-Twitter-Client-Version:" => $conf{clientver} );
$conf{tvua}->default_header( "X-Twitter-Client-URL:" => $conf{clienturl} );
$conf{tvua}->env_proxy();
}
$conf{skip_arg_validation} = 0 unless defined $conf{skip_arg_validation};
$conf{die_on_validation} = 0 unless defined $conf{die_on_validation};
$conf{error_return_val} =
( ( defined $conf{arrayref_on_error} ) and ( $conf{arrayref_on_error} ) ) ? [] : undef;
$conf{response_error} = undef;
$conf{response_code} = undef;
$conf{response_method} = undef;
return bless {%conf}, $class;
}
### Return a shallow copy of the object to allow error handling when used in
### Parallel/Async setups like POE. Set response_error to undef to prevent
### spillover, just in case.
sub clone {
my $self = shift;
bless { %{$self}, response_error => $self->{error_return_val} };
}
### Change the credentials
sub credentials {
my ( $self, $username, $password, $apihost, $apirealm ) = @_;
$apirealm ||= 'Twitter API';
$apihost ||= 'twitter.com:80';
$self->{ua}->credentials( $apihost, $apirealm, $username, $password );
}
sub get_error {
my $self = shift;
my $response = eval { JSON::Any->jsonToObj( $self->{response_error} ) };
if ( !defined $response ) {
$response = {
request => undef,
error => "TWITTER RETURNED ERROR MESSAGE BUT PARSING OF THE JSON RESPONSE FAILED - "
. $self->{response_error}
};
}
return $response;
}
sub http_code {
my $self = shift;
return $self->{response_code};
}
sub http_message {
my $self = shift;
return $self->{response_message};
}
sub update_twittervision {
my ( $self, $location ) = @_;
my $response;
if ( $self->{twittervision} ) {
my $tvreq =
$self->{tvua}
->post( $self->{tvurl} . "/user/update_location.json", [ location => uri_escape($location) ] );
if ( $tvreq->content ne "User not found" ) {
$self->{response_code} = $tvreq->code;
$self->{response_message} = $tvreq->message;
$self->{response_error} = $tvreq->content;
if ( $tvreq->is_success ) {
$response = eval { JSON::Any->jsonToObj( $tvreq->content ) };
if ( !defined $response ) {
$self->{response_error} =
"TWITTERVISION RETURNED SUCCESS BUT PARSING OF THE RESPONSE FAILED - "
. $tvreq->content;
}
}
}
}
return $response;
}
sub search {
my $self = shift;
my $args = shift;
my $url = $self->{searchapiurl} . "?";
my $retval;
### Return if no args specified.
if ( !defined($args) ) {
carp "No query string specified";
return $self->{error_return_val};
}
### If the first argument passed is a string, convert it into a hashref
### with the arg assigned to the key "q"
if ( !ref($args) ) {
$args = { "q" => $args };
}
### Allow use of "query", but use the argument "q"
### This has the side effect of overwriting q with query
if ( defined $args->{query} ) {
if ( defined $args->{q} ) {
carp "Both 'q' and 'query' specified, using value of 'query'.";
}
$args->{q} = delete( $args->{query} );
}
### For backcompat with Br3nda's N::T::Search, allow a hashref as a second
### argument. Here we just combine with the previous arg, so there's only
### one hashref to deal with
my $otherargs = shift;
if ( ref($otherargs) eq "HASH" ) {
if ( ( defined $otherargs->{q} ) || ( defined $otherargs->{query} ) ) {
carp "Specifed a query both as a plain text first arg and in the hashref second arg.";
carp "Using query from first arg";
}
$otherargs->{"q"} = $args->{"q"};
$args = $otherargs;
}
### Make a string out of the args to append to the URL.
foreach my $argname ( sort keys %{$args} ) {
# drop arguments with undefined values
next unless defined $args->{$argname};
$url .= "&" unless substr( $url, -1 ) eq "?";
$url .= $argname . "=" . uri_escape( $args->{$argname} );
}
### Make the request, store the results.
my $req = $self->{ua}->get($url);
$self->{response_code} = $req->code;
$self->{response_message} = $req->message;
$self->{response_error} = $req->content;
undef $retval;
### Trap a case where twitter could return a 200 success but give up badly formed JSON
### which would cause it to die. This way it simply assigns undef to $retval
### If this happens, response_code, response_message and response_error aren't going to
### have any indication what's wrong, so we prepend a statement to request_error.
if ( $req->is_success ) {
$retval = eval { JSON::Any->jsonToObj( $req->content ) };
if ( !defined $retval ) {
$self->{response_error} =
"TWITTER RETURNED SUCCESS BUT PARSING OF THE RESPONSE FAILED - " . $req->content;
return $self->{error_return_val};
}
}
return $retval;
}
### Load method data into %apicalls at runtime.
BEGIN {
### Have to turn strict refs off in order to insert subrefs by value.
no strict "refs";
*{_get_apicalls} = sub {
my $api = {
"public_timeline" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/statuses/public_timeline",
"args" => {},
},
"friends_timeline" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/statuses/friends_timeline",
"args" => {
"since" => 0,
"since_id" => 0,
"count" => 0,
"page" => 0,
},
},
"user_timeline" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/statuses/user_timeline/ID",
"args" => {
"id" => 0,
"since" => 0,
"since_id" => 0,
"count" => 0,
"page" => 0,
},
},
"show_status" => {
"blankargs" => 0,
"post" => 0,
"uri" => "/statuses/show/ID",
"args" => { "id" => 1, },
},
"update" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/statuses/update",
"args" => {
"status" => 1,
"in_reply_to_status_id" => 0,
"source" => 0,
},
},
"replies" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/statuses/replies",
"args" => {
"page" => 0,
"since" => 0,
"since_id" => 0,
},
},
"destroy_status" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/statuses/destroy/ID",
"args" => { "id" => 1, },
},
"friends" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/statuses/friends/ID",
"args" => {
"id" => 0,
"page" => 0,
"since" => 0,
},
},
"followers" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/statuses/followers",
"args" => {
"id" => 0,
"page" => 0,
},
},
"show_user" => {
"blankargs" => 0,
"post" => 0,
"uri" => "/users/show/ID",
"args" => {
"id" => 1,
"email" => 1,
},
},
"direct_messages" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/direct_messages",
"args" => {
"since" => 0,
"since_id" => 0,
"page" => 0,
},
},
"sent_direct_messages" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/direct_messages/sent",
"args" => {
"since" => 0,
"since_id" => 0,
"page" => 0,
},
},
"new_direct_message" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/direct_messages/new",
"args" => {
"user" => 1,
"text" => 1,
},
},
"destroy_direct_message" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/direct_messages/destroy/ID",
"args" => { "id" => 1, },
},
"create_friend" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/friendships/create/ID",
"args" => {
"id" => 1,
"follow" => 0,
},
},
"destroy_friend" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/friendships/destroy/ID",
"args" => { "id" => 1, },
},
"relationship_exists" => {
"blankargs" => 0,
"post" => 0,
"uri" => "/friendships/exists",
"args" => {
"user_a" => 1,
"user_b" => 1,
},
},
"friends_ids" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/friends/ids/ID",
"args" => { "id" => 0, },
},
"followers_ids" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/followers/ids/ID",
"args" => { "id" => 0, },
},
"verify_credentials" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/account/verify_credentials",
"args" => {},
},
"end_session" => {
"blankargs" => 1,
"post" => 1,
"uri" => "/account/end_session",
"args" => {},
},
"update_profile" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/account/update_profile",
"args" => {
"name" => 0,
"email" => 0,
"url" => 0,
"location" => 0,
"description" => 0,
},
},
"update_profile_colors" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/account/update_profile_colors",
"args" => {
"profile_background_color" => 0,
"profile_text_color" => 0,
"profile_link_color" => 0,
"profile_sidebar_fill_color" => 0,
"profile_sidebar_border_color" => 0,
},
},
"update_profile_image" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/account/update_profile_image",
"args" => { "image" => 1, },
},
"update_profile_background_image" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/account/update_profile_background_image",
"args" => { "image" => 1, },
},
"update_delivery_device" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/account/update_delivery_device",
"args" => { "device" => 1, },
},
"rate_limit_status" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/account/rate_limit_status",
"args" => {},
},
"favorites" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/favorites",
"args" => {
"id" => 0,
"page" => 0,
},
},
"create_favorite" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/favorites/create/ID",
"args" => { "id" => 1, },
},
"destroy_favorite" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/favorites/destroy/ID",
"args" => { "id" => 1, },
},
"enable_notifications" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/notifications/follow/ID",
"args" => { "id" => 1, },
},
"disable_notifications" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/notifications/leave/ID",
"args" => { "id" => 1, },
},
"create_block" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/blocks/create/ID",
"args" => { "id" => 1, },
},
"destroy_block" => {
"blankargs" => 0,
"post" => 1,
"uri" => "/blocks/destroy/ID",
"args" => { "id" => 1, },
},
"test" => {
"blankargs" => 1,
"post" => 0,
"uri" => "/help/test",
"args" => {},
},
"downtime_schedule" => {
"blankargs" => 100,
"post" => 0,
"uri" => "/help/downtime_schedule",
"args" => {},
},
};
};
### For each method name in %apicalls insert a stub method to handle request.
my %apicalls = %{ _get_apicalls() };
foreach my $methodname ( keys %apicalls ) {
*{$methodname} = sub {
my $self = shift;
my $args = shift;
my $whoami;
my $url = $self->{apiurl};
my $seen_id = 0;
my $retval;
### Store the method name, since a sub doesn't know it's name without
### a bit of work and more dependancies than are really prudent.
eval { $whoami = $methodname };
### Get this method's definition from the table
my $method_def = $apicalls{$whoami};
### Set the correct request type for this method
my $reqtype = ( $method_def->{post} ) ? "POST" : "GET";
### Check if no args sent and args are required.
if ( ( !defined $args ) && ( !$method_def->{blankargs} ) ) {
if ( $self->{die_on_validation} ) {
croak "The method $whoami requires arguments and none specified. Terminating.";
} else {
carp "The method $whoami requires arguments and none specified. Discarding request";
$self->{response_error} = {
"request" => $url,
"error" => "The method $whoami requires arguments and none specified."
};
}
return $self->{error_return_val};
}
### For backwards compatibility we need to handle the user handing a single, scalar
### arg in, instead of a hashref. Since the methods that allowed this in 1.xx have
### different defaults, use a bit of logic to stick the value in the right place.
my %idsubs = map { $_ => 1 } qw (
create_block
destroy_block
friends
show_user
create_friend
destroy_friend
destroy_direct_message
show_status
create_favorite
destroy_favorite
destroy_status
disable_notifications
enable_notifications
favorites
followers
user_timeline
friends_ids
followers_ids
);
if ( ( !ref($args) ) && ( defined $args ) ) {
if ( $whoami eq "relationship_exists" ) {
my $user_b = shift;
$args = { "user_a" => $args, "user_b" => $user_b };
} elsif ( $whoami eq "update" ) {
$args = { "status" => $args };
} elsif ( $whoami eq "replies" ) {
$args = { "page" => $args };
} elsif ( exists $idsubs{$whoami} ) {
$args = { "id" => $args };
} elsif ( $whoami =~ m/update_profile_image|update_profile_background_image/ ) {
$args = { "image" => $args };
} elsif ( $whoami eq "update_delivery_device" ) {
$args = { "device" => $args };
} elsif ( $whoami eq "update_location" ) {
$args = { "location" => $args };
} else {
### $args is not a hashref and $whoami is not one of the legacy
### subs, so we punt.
if ( $self->{die_on_validation} ) {
croak "Argument is not a HASHREF. Terminating.";
} else {
carp "Argument is not a HASHREF. Discarding request";
$self->{response_error} = {
"request" => $url,
"error" => "Argument is not a HASHREF."
};
}
return $self->{error_return_val};
}
}
### Handle source arg for update method.
if ( $whoami eq "update" ) {
$args->{source} = $self->{source};
}
### Create the URL. If it ends in /ID it needs the id param substituted
### into the URL and not as an arg.
if ( ( my $uri = $method_def->{uri} ) =~ s|/ID|| ) {
if ( defined $args->{id} ) {
$url .= $uri . "/" . delete( $args->{id} ) . ".json";
$seen_id++;
} elsif ( $whoami eq "show_user" ) {
### show_user requires either id or email, this workaround checks that email is
### passed if id is not.
if ( !defined $args->{email} ) {
carp "Either id or email is required by show_user, discarding request.";
$self->{response_error} = {
"request" => $method_def->{uri},
"error" => "Either id or email is required by show_user, discarding request.",
};
return $self->{error_return_val};
}
$url .= "$uri.json";
} else {
### No id field is found but may be optional. If so, skip id in the URL and just
### tack on .json, otherwise warn and return undef
if ( $method_def->{args}->{id} ) {
carp "The field id is required and not specified";
$self->{response_error} = {
"request" => $method_def->{uri},
"error" => "The field id is required and not specified",
};
return $self->{error_return_val};
} else {
$url .= $uri . ".json";
}
}
} else {
$url .= $uri . ".json";
}
### Validate args. Don't validate if $args is undef, we've already checked that
### undef is OK to pass up above
if ( defined $args ) {
foreach my $argname ( sort keys %{ $method_def->{args} } ) {
if ( $whoami eq "show_user" ) {
### We already validated the wonky args to show_user above.
next;
}
if ( ( $argname eq "id" ) and ($seen_id) ) {
### We've already handled id by putting it in the url, it doesn't
### go in the args.
next;
}
if ( !$self->{skip_arg_validation} ) {
if ( ( $method_def->{args}->{$argname} )
and ( !defined $args->{$argname} ) )
{
if ( $self->{die_on_validation} ) {
croak "The field $argname is required and not specified. Terminating.";
} else {
carp "The field $argname is required and not specified, discarding request.";
$self->{response_error} = {
"request" => $url,
"error" => "The field $argname is required and not specified"
};
}
return $self->{error_return_val};
}
}
}
}
### Final Validation of $args, Drop args that are named but undefined, and complain when
### bogus args are passed.
if ( !$self->{skip_arg_validation} ) {
foreach my $argkey ( sort keys %{$args} ) {
if ( !defined $args->{$argkey} ) {
carp "Argument $argkey specified as undef, discarding.";
$self->{response_error} = {
"request" => $url,
"error" => "Argument $argkey specified as undef."
};
delete $args->{$argkey};
} elsif ( !exists $method_def->{args}->{$argkey} ) {
carp "Unknown argument $argkey passed, discarding.";
$self->{response_error} = {
"request" => $url,
"error" => "Unknown argument $argkey passed."
};
delete $args->{$argkey};
}
}
}
### Send the LWP request
my $req;
if ( $reqtype eq 'POST' ) {
$req = $self->{ua}->post( $url, $args );
} else {
my $uri = URI->new($url);
$uri->query_form($args);
$req = $self->{ua}->get($uri);
}
$self->{response_code} = $req->code;
$self->{response_message} = $req->message;
$self->{response_error} = $req->content;
undef $retval;
if ( $req->is_success ) {
$retval = eval { JSON::Any->jsonToObj( $req->content ) };
### Trap a case where twitter could return a 200 success but give up badly formed JSON
### which would cause it to die. This way it simply assigns undef to $retval
### If this happens, response_code, response_message and response_error aren't going to
### have any indication what's wrong, so we prepend a statement to request_error.
if ( !defined $retval ) {
$self->{response_error} =
"TWITTER RETURNED SUCCESS BUT PARSING OF THE RESPONSE FAILED - " . $req->content;
return $self->{error_return_val};
}
}
return $retval;
}
}
}
1;
__END__
=head1 NAME
Net::Twitter - Perl interface to twitter.com
=head1 VERSION
This document describes Net::Twitter version 2.12
=head1 SYNOPSIS
#!/usr/bin/perl
use Net::Twitter;
my $twit = Net::Twitter->new({username=>"myuser", password=>"mypass" });
my $result = $twit->update({status => "My current Status"});
my $twit->credentials("otheruser", "otherpass");
my $result = $twit->update({status => "Status for otheruser"});
my $result = $twitter->search('Albi the racist dragon');
foreach my $tweet (@{ $results }) {
my $speaker = $tweet->{from_user};
my $text = $tweet->{text};
my $time = $tweet->{created_at};
print "$time <$speaker> $text\n";
}
my $steve = $twitter->search('Steve');
$twitter->update($steve .'? Who is steve?');
=head1 DESCRIPTION
http://www.twitter.com provides a web 2.0 type of ubiquitous presence.
This module allows you to set your status, as well as review the statuses of
your friends.
You can view the latest status of Net::Twitter on it's own twitter timeline
at http://twitter.com/net_twitter
=head1 METHODS AND ARGUMENTS
Listed below are the methods available through the object.
Please note that any method that takes a hashref as an argument must be called
in the form:
$twit->method({arg => "value"});
and not
$twit->method(arg => "value");
If the curly brackets around the arguments are missing, the code which implements the
convenience methods allowing you to specify a single argument as a string will interpret
"arg" as your argument.
=over
=item C<new(...)>
You must supply a hash containing the configuration for the connection.
Valid configuration items are:
=over
=item C<username>
Username of your account at twitter.com. This is usually your email address.
"user" is an alias for "username". REQUIRED.
=item C<password>
Password of your account at twitter.com. "pass" is an alias for "password"
REQUIRED.
=item C<useragent>
OPTIONAL: Sets the User Agent header in the HTTP request. If omitted, this will default to
"Net::Twitter/$Net::Twitter::Version (Perl)"
=item C<useragent_class>
OPTIONAL: An L<LWP::UserAgent> compatible class, e.g., L<LWP::UserAgent::POE>.
If omitted, this will default to L<LWP::UserAgent>.
=item C<useragent_args>
OPTIONAL: A hashref passed to this option will be passed along to the UserAgent C<new()>
call to specify its configuration. This will pass to whatever class is passed in
C<useragent_class>, if any. See the POD for L<LWP::UserAgent> for details.
NOTE: Any value passed in this hashref for "agent" will be overwritten. If setting the
useragent is necessary, use the C<useragent> option to C<new()>
=item C<no_fallback>
OPTIONAL: If a C<useragent_class> is specified but fails to load, the default behavior is
to warn and fall back to using regular L<LWP::UserAgent>. If C<no_fallback> is set to a boolean true
value, the C<new> method will cause the code to C<die>
=item C<source>
OPTIONAL: Sets the source name, so messages will appear as "from <source>" instead
of "from web". Defaults to displaying "Perl Net::Twitter". Note: see Twitter FAQ,
your client source needs to be included at twitter manually.
This value will be a code which is assigned to you by Twitter. For example, the
default value is "twitterpm", which causes Twitter to display the "from Perl
Net::Twitter" in your timeline.
Twitter claims that specifying a nonexistant code will cause the system to default to
"from web". If you don't have a code from twitter, don't set one.
=item C<clientname>
OPTIONAL: Sets the X-Twitter-Client-Name: HTTP Header. If omitted, this defaults to
"Perl Net::Twitter"
=item C<clientver>
OPTIONAL: Sets the X-Twitter-Client-Version: HTTP Header. If omitted, this defaults to
the current Net::Twitter version, $Net::Twitter::VERSION.
=item C<clienturl>
OPTIONAL: Sets the X-Twitter-Client-URL: HTTP Header. If omitted, this defaults to
C<http://www.net-twitter.info>.
=item C<apiurl>
OPTIONAL. The URL of the API for twitter.com. This defaults to
C<http://twitter.com/> if not set.
=item C<apihost>
=item C<apirealm>
OPTIONAL: If you do point to a different URL, you will also need to set C<apihost> and
C<apirealm> so that the internal LWP can authenticate.
C<apihost> defaults to C<www.twitter.com:80>.
C<apirealm> defaults to C<Twitter API>.
=item C<identica>
OPTIONAL: Passing a true value for identica to new() will preset values for C<apiurl>, C<apirealm> and
C<apihost> which will point at the http://identi.ca twitter compatible API.
All methods in Net::Twitter work as documented, except where listed in the
identica/laconica documentation at:
L<http://laconi.ca/trac/wiki/TwitterCompatibleAPI>
For simplicity, you can also use L<Net::Identica> in your script instead of Net::Twitter, which
will default to identica being set to true.
=item C<twittervision>
OPTIONAL: If the C<twittervision> argument is passed with a true value, the
module will enable use of the L<http://www.twittervision.com> API. If
enabled, the C<show_user> method will include relevant location data in
its response hashref. Also, the C<update_twittervision> method will
allow setting of the current location.
=item C<skip_arg_validation>
OPTIONAL: Beginning in 2.00, Net::Twitter will validate arguments passed to the various API methods,
flagging required args that were not passed, and discarding args passed that do not exist in the API
specification. Passing a boolean True for skip_arg_validation into new() will skip this validation
process entirely and allow requests to proceed regardless of the args passed. This defaults to false.
=item C<die_on_validation>
OPTIONAL: In the event that the arguments passed to a method do not pass the validation process listed
above, the default action will be to warn the user, make the error readable through the get_error method
listed below, and to return undef to the caller. Passing a boolean true value for die_on_validation to
new() will change this behavior to simply executing a die() with the appropriate error message. This
defaults to false.
=item C<arrayref_on_error>
OPTIONAL: By default any methods which find an error, whether from twitter or from bad args, will
return undef. Passing C<arrayref_on_error> as a boolean TRUE to new() will cause all error states to
return an empty arrayref instead. As most successful responses are in the form of arrayrefs, this will
cause a uniform response type for all calls. All error messages and codes are still available with
methods such as C<get_error>.
=back
=item C<clone()>
Returns a shallow copy of the Net::Twitter object. This can be used when Net::Twitter is used in
a Parallel or Asynchronous framework to enable easier access to returned error values. All clones share
the same LWP::UserAgent object, so calling C<credentials()> will change the login credentials of all
clones.
=item C<credentials($username, $password, $apihost, $apiurl)>
Change the credentials for logging into twitter. This is helpful when managing
multiple accounts.
C<apirealm> and C<apihost> are optional and will default to the existing settings if omitted.
=item C<http_code>
Returns the HTTP response code of the most recent request.
=item C<http_message>
Returns the HTTP response message of the most recent request.
=item C<get_error>
If the last request returned an error, the hashref containing the error message can be
retrieved with C<get_error>. This will provide some additional debugging information in
addition to the http code and message above.
=back
=head2 STATUS METHODS
=over
=item C<update(...)>
Set your current status. This returns a hashref containing your most
recent status. Returns undef if an error occurs.
The method accepts a hashref containing one or two arguments.
=over
=item C<status>
REQUIRED. The text of your status update.
=item C<in_reply_to_status_id>
OPTIONAL. The ID of an existing status that the status to be posted is in reply to.
This implicitly sets the in_reply_to_user_id attribute of the resulting status to
the user ID of the message being replied to. Invalid/missing status IDs will be ignored.
=back
=item C<update_twittervision($location)>
If the C<twittervision> argument is passed to C<new> when the object is
created, this method will update your location setting at
twittervision.com.
If the C<twittervision> arg is not set at object creation, this method will
return an empty hashref, otherwise it will return a hashref containing the
location data.
=item C<show_status($id)>
Returns status of a single tweet. The status' author will be returned inline.
The argument is the ID or email address of the twitter user to pull, and is REQUIRED.
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id".
=item C<destroy_status($id)>
Destroys the status specified by the required ID parameter. The
authenticating user must be the author of the specified status.
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id".
=item C<user_timeline(...)>
This returns an arrayref to an array of hashrefs, containing the 20 (or more) posts from
either the authenticating user (if no argument is passed), or from a specific user if
the id field is passed in a hashref.
Accepts an optional argument of a hashref:
=over
=item C<id>
OPTIONAL: ID or email address of a user other than the authenticated user, in
order to retrieve that user's user_timeline.
=item C<since>
OPTIONAL: Narrows the returned results to just those statuses created after the
specified HTTP-formatted date.
=item C<since_id>
OPTIONAL: Narrows the returned results to just those statuses created after the
specified ID.
=item C<count>
OPTIONAL: Narrows the returned results to a certain number of statuses. This is limited to 200.
=item C<page>
OPTIONAL: Gets the 20 next most recent statuses from the authenticating user and that user's
friends, eg "page=3".
=back
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id". If passed as a string, no other args can be specified.
=item C<public_timeline()>
This returns an arrayref to an array of hashrefs, containing the information and status of
each of the last 20 posts by all non-private twitter users.
=item C<friends_timeline(...)>
Returns the 20 most recent statuses posted from the authenticating user and that user's
friends. It's also possible to request another user's friends_timeline via the id parameter below.
If called with no arguments, returns the friends' timeline for the authenticating user.
Accepts an optional hashref as an argument:
=over
=item C<since>
OPTIONAL: Narrows the returned results to just those statuses created after the
specified HTTP-formatted date.
=item C<since_id>
OPTIONAL: Narrows the returned results to just those statuses created after the
specified ID.
=item C<count>
Narrows the returned results to a certain number of statuses. This is limited to 200.
=item C<page>
Gets the 20 next most recent statuses from the authenticating user and that user's
friends, eg "page=3".
=back
=item C<replies(...)>
This returns an arrayref to an array of hashrefs, containing the information and status of
each of the last 20 replies (status updates prefixed with @username
posted by users who are friends with the user being replied to) to the
authenticating user.
=over
=item C<since>
OPTIONAL: Narrows the returned results to just those replies created after the specified HTTP-formatted date,
up to 24 hours old.
=item C<since_id>
OPTIONAL: Returns only statuses with an ID greater than (that is, more recent than) the specified ID.
=item C<page>
OPTIONAL: Gets the 20 next most recent replies.
=back
=back
=head2 USER METHODS
=over
=item C<friends()>
This returns an arrayref to an array of hashrefs. Each hashref contains the information and status of those you
have marked as friends in twitter. Returns undef if an error occurs.
Takes a hashref as an arg:
=over
=item C<since>
OPTIONAL: Narrows the returned results to just those friendships created after the specified HTTP-formatted date,
up to 24 hours old.
=item C<id>
OPTIONAL: User id or email address of a user other than the authenticated user,
in order to retrieve that user's friends.
=item C<page>
OPTIONAL: Gets the 100 next most recent friends, eg "page=3".
=back
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id". If passed as a string, no other args can be specified.
=item C<followers()>
his returns an arrayref to an array of hashrefs. Each hashref contains the information
and status of those who follow your status in twitter. Returns undef if an error occurs.
If called without an argument returns the followers for the authenticating user, but can
pull followers for a specific ID.
Accepts an optional hashref for arguments:
=over
=item C<id>
OPTIONAL: The ID or screen name of the user for whom to request a list of followers.
=item C<page>
OPTIONAL: Retrieves the next 100 followers.
=back
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id". If passed as a string, no other args can be specified.
=item C<show_user()>
Returns a hashref containing extended information of a single user.
The argument is a hashref containing either the user's ID or email address. It is required
to pass either one or the other, but not both:
=over
=item C<id>
The ID or screen name of the user.
=item C<email>
The email address of the user. If C<email> is specified, C<id> is ignored.
=back
If the C<twittervision> argument is passed to C<new> when the object is
created, this method will include the location information for the user
from twittervision.com, placing it inside the returned hashref under the
key C<twittervision>.
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id". If passed as a string, no other args can be specified.
=back
=head2 DIRECT MESSAGE METHODS
=over
=item C<direct_messages()>
Returns a list of the direct messages sent to the authenticating user.
Accepts an optional hashref for arguments:
=over
=item C<page>
OPTIONAL: Retrieves the 20 next most recent direct messages.
=item C<since>
OPTIONAL: Narrows the returned results to just those statuses created after the
specified HTTP-formatted date.
=item C<since_id>
OPTIONAL: Narrows the returned results to just those statuses created after the
specified ID.
=back
=item C<sent_direct_messages()>
Returns a list of the direct messages sent by the authenticating user.
Accepts an optional hashref for arguments:
=over
=item C<page>
OPTIONAL: Retrieves the 20 next most recent direct messages.
=item C<since>
OPTIONAL: Narrows the returned results to just those statuses created after the
specified HTTP-formatted date.
=item C<since_id>
OPTIONAL: Narrows the returned results to just those statuses created after the
specified ID.
=back
=item C<new_direct_message($args)>
Sends a new direct message to the specified user from the authenticating user.
REQUIRES an argument of a hashref:
=over
=item C<user>
REQUIRED: ID or email address of user to send direct message to.
=item C<text>
REQUIRED: Text of direct message.
=back
=item C<destroy_direct_message($id)>
Destroys the direct message specified in the required ID parameter. The
authenticating user must be the recipient of the specified direct message.
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id".
=back
=head2 FRIENDSHIP METHODS
=over
=item C<create_friend(...)>
Befriends the user specified in the id parameter as the authenticating user.
Returns a hashref containing the befriended user's information when successful.
=over
=item C<id>
REQUIRED. The ID or screen name of the user to befriend.
=item C<follow>
OPTIONAL. Enable notifications for the target user in addition to becoming friends.
=back
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id". If passed as a string, no other args can be specified.
=item C<destroy_friend($id)>
Discontinues friendship with the user specified in the ID parameter as the
authenticating user. Returns a hashref containing the unfriended user's information
when successful.
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id".
=item C<relationship_exists($user_a, $user_b)>
Tests if friendship exists between the two users specified as arguments. Both arguments
are REQUIRED.
=back
=head2 SOCIAL GRAPH METHODS
=over
=item C<friends_ids()>
Returns an arrayref to an array of numeric IDs for every user the specified user is following.
Returns undef if an error occurs.
Takes a hashref as an arg:
=over
=item C<id>
OPTIONAL: User id or email address of a user other than the authenticated user,
in order to retrieve that user's friends.
=back
This method can take the "id" argument passed to it either as a single string, or in a
hashref with a key called "id". If passed as a string, no other args can be specified.
If no args are passed, returns the list for the authenticating user.
=item C<followers_ids()>
Returns an arrayref to an array of numeric IDs for every user the specified user is followed
by. Returns undef if an error occurs.
Accepts an optional hashref for arguments:
=over
=item C<id>
OPTIONAL: The ID or screen name of the user for whom to request a list of followers.
=back
This method can take the "id" argument passed to it either as a single string, or in a
hashref with a key called "id". If passed as a string, no other args can be specified.
If no args are passed, returns the list for the authenticating user.
=back
=head2 ACCOUNT METHODS
=over
=item C<verify_credentials()>
Returns a hashref containing the authenticating user's extended information if the login
credentials are correct.
=item C<end_session()>
Ends the session of the authenticating user, returning a null cookie. Use
this method to sign users out of client-facing applications like widgets.
=item C<update_location($location)>
WARNING: This method has been deprecated in favor of the update_profile method below.
It still functions today but will be removed in future versions.
Updates the location attribute of the authenticating user, as displayed on
the side of their profile and returned in various API methods.
=item C<update_delivery_device($device)>
Sets which device Twitter delivers updates to for the authenticating user.
$device is required and must be one of: "sms", "im", or "none". Sending none as the device
parameter will disable IM or SMS updates.
=item C<update_profile_colors(...)>
Sets one or more hex values that control the color scheme of the authenticating user's profile
page on twitter.com. These values are also returned in the show_user method.
This method takes a hashref as an argument, with the following optional fields
containing a hex color string.
=over
=item C<profile_background_color>
=item C<profile_text_color>
=item C<profile_link_color>
=item C<profile_sidebar_fill_color>
=item C<profile_sidebar_border_color>
=back
=item C<update_profile_image(...)>)
Updates the authenticating user's profile image.
This takes as a required argument a GIF, JPG or PNG image, no larger than 700k in size.
Expects raw image data, not a pathname or URL to the image.
=item C<update_profile_background_image(...)>)
Updates the authenticating user's profile background image.
This takes as a required argument a GIF, JPG or PNG image, no larger than 800k in size.
Expects raw image data, not a pathname or URL to the image.
=item C<rate_limit_status>
Returns the remaining number of API requests available to the authenticating
user before the API limit is reached for the current hour. Calls to
rate_limit_status require authentication, but will not count against
the rate limit.
=item C<update_profile>
Sets values that users are able to set under the "Account" tab of their settings page.
Takes as an argument a hashref containing fields to be updated. Only the parameters specified
will be updated. For example, to only update the "name" attribute include only that parameter
in the hashref.
=over
=item C<name>
OPTIONAL: Twitter user's name. Maximum of 40 characters.
=item C<email>
OPTIONAL: Email address. Maximum of 40 characters. Must be a valid email address.
=item C<url>
OPTIONAL: Homepage URL. Maximum of 100 characters. Will be prepended with "http://" if not present.
=item C<location>
OPTIONAL: Geographic location. Maximum of 30 characters. The contents are not normalized or
geocoded in any way.
=item C<description>
OPTIONAL: Personal description. Maximum of 160 characters.
=back
=back
=head2 FAVORITE METHODS
=over
=item C<favorites()>
Returns the 20 most recent favorite statuses for the authenticating user or user
specified by the ID parameter.
This takes a hashref as an argument:
=over
=item C<id>
OPTIONAL. The ID or screen name of the user for whom to request a list of favorite
statuses.
=item C<page>
OPTIONAL: Gets the 20 next most recent favorite statuses, eg "page=3".
=back
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id". If passed as a string, no other args can be specified.
=item C<create_favorite()>
Sets the specified ID as a favorite for the authenticating user.
This takes a hashref as an argument:
=over
=item C<id>
REQUIRED: The ID of the status to favorite.
=back
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id".
=item C<destroy_favorite()>
Removes the specified ID as a favorite for the authenticating user.
This takes a hashref as an argument:
=over
=item C<id>
REQUIRED. The ID of the status to un-favorite.
=back
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id".
=back
=head2 NOTIFICATION METHODS
=over
=item C<enable_notifications()>
Enables notifications for updates from the specified user to the authenticating user.
Returns the specified user when successful.
This takes a hashref as an argument:
=over
=item C<id>
REQUIRED: The ID or screen name of the user to receive notices from.
=back
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id".
=item C<disable_notifications()>
Disables notifications for updates from the specified user to the authenticating user.
Returns the specified user when successful.
This takes a hashref as an argument:
=over
=item C<id>
REQUIRED: The ID or screen name of the user to stop receiving notices from.
=back
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id".
=back
=head2 BLOCK METHODS
=over
=item C<create_block($id)>
Blocks the user id passed as an argument from the authenticating user.
Returns a hashref containing the user information for the blocked user when successful.
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id".
You can find more information about blocking at
L<http://help.twitter.com/index.php?pg=kb.page&id=69>.
=item C<destroy_block($id)>
Un-blocks the user id passed as an argument from the authenticating user.
Returns a hashref containing the user information for the blocked user when successful.
This method can take the "id" argument passed to it either as a single string, or in a hashref with a key
called "id".
=back
=head2 SEARCH
As of version 2.00, Net::Twitter implements the search functionality of Twitter,
using code derived from Net::Twitter::Search by Brenda Wallace.
=over
=item C<search()>
Performs a search on http://search.twitter.com for your query string.
This returns a hashref which is slightly different than the other methods such as public_timeline.
The hashref contains a key named C<results> which contains an arrayref to an array of hashrefs, each
hashref containing a single post. These hashrefs do not include the "user" item with the
posting user's information such as the *_timeline methods do.
This method takes a required hashref as an argument:
=over
=item C<q>
=item C<query>
REQUIRED: Specifies the string to search for. This can include any of the Twitter search operators listed
at L<http://search.twitter.com/operators>. Please see below for information about backwards compatibility
with Net::Twitter::Search.
Both q and query are aliases to the same argument. Specifying both will use
the value specified for "query".
Please note that you cannot use the "near" search operator to specify arbitrary Lat/Long locations.
For this use the C<geocode> argument below.
=item C<lang>
OPTIONAL: Restricts results to a specific language, given by an ISO 639-1 code. For example {'lang' => 'en'}
=item C<rpp>
OPTIONAL: Sets the number of posts to return per page, up to a max of 100.
=item C<page>
OPTIONAL: Sets the page number (starting at 1) to return, up to a max of roughly
1500 results (based on rpp * page)
=item C<since_id>
OPTIONAL: Restricts returned posts to those status ids greater than the given id.
=item C<geocode>
OPTIONAL: Returns posts by users located within the radius of the given latitude/longitude, where the user's
location is taken from their Twitter profile. The format of the parameter value is "latitide,longitude,radius",
with radius units specified as either "mi" (miles) or "km" (kilometers).
=item C<show_user>
OPTIONAL: When set to a true boolean value C<show_user> will prepend "<username>:" to the beginning of the text of
each post returned.
=back
=item BACKWARDS COMPATIBILITY WITH Net::Twitter::Search
In order to maintain backwards compatibility with Net::Twitter::Search, the query/q arguments can be specified
as plain text:
$res = $twit->search("Farkle McFancypants")
In addition, you can, in this case, specify all of the above arguments in a hashref as the second argument
to the search method.
$res = $twit->search("Farkle McFancypants", {lang => "en"})
Any query/q arguments in the hashref passed in this manner will be ignored, and the module will
proceed using the string passed in the first argument as the query.
=back
=head2 HELP METHODS
=over
=item C<test()>
Returns the string "ok" in the requested format with a 200 OK HTTP status
code.
=item C<downtime_schedule()>
Returns the same text displayed on L<http://twitter.com/home> when a
maintenance window is scheduled.
=back
=head1 BUGS AND LIMITATIONS
Please report any bugs or feature requests to
C<[email protected]>, or through the web interface at
L<https://rt.cpan.org/Dist/Display.html?Queue=Net-Twitter>.
You can also join the Net::Twitter IRC channel at irc://irc.perl.org/net-twitter
You can track Net::Twitter development at http://github.com/ct/net-twitter/tree/2.0
=head1 AUTHOR
Chris Thompson <[email protected]>
The test framework for Net::Twitter was written by Marc "semifor" Mims.
The framework of this module is shamelessly stolen from L<Net::AIML>. Big
ups to Chris "perigrin" Prather for that.
=head1 LICENCE AND COPYRIGHT
Copyright (c) 2009, Chris Thompson <[email protected]>. All rights
reserved.
This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself. See L<perlartistic>.
=head1 DISCLAIMER OF WARRANTY
BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH
YOU. SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
NECESSARY SERVICING, REPAIR, OR CORRECTION.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE SOFTWARE AS PERMITTED BY THE ABOVE LICENCE, BE
LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL,
OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
THE SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE SOFTWARE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
| 32.254805 | 114 | 0.587715 |
73fedaf819f62eef16f21777a1bf02e9150cd82a | 3,726 | pm | Perl | auto-lib/Paws/SimpleWorkflow/RequestCancelExternalWorkflowExecutionFailedEventAttributes.pm | 0leksii/aws-sdk-perl | b2132fe3c79a06fd15b6137e8a0eb628de722e0f | [
"Apache-2.0"
] | 164 | 2015-01-08T14:58:53.000Z | 2022-02-20T19:16:24.000Z | auto-lib/Paws/SimpleWorkflow/RequestCancelExternalWorkflowExecutionFailedEventAttributes.pm | 0leksii/aws-sdk-perl | b2132fe3c79a06fd15b6137e8a0eb628de722e0f | [
"Apache-2.0"
] | 348 | 2015-01-07T22:08:38.000Z | 2022-01-27T14:34:44.000Z | auto-lib/Paws/SimpleWorkflow/RequestCancelExternalWorkflowExecutionFailedEventAttributes.pm | 0leksii/aws-sdk-perl | b2132fe3c79a06fd15b6137e8a0eb628de722e0f | [
"Apache-2.0"
] | 87 | 2015-04-22T06:29:47.000Z | 2021-09-29T14:45:55.000Z | # Generated by default/object.tt
package Paws::SimpleWorkflow::RequestCancelExternalWorkflowExecutionFailedEventAttributes;
use Moose;
has Cause => (is => 'ro', isa => 'Str', request_name => 'cause', traits => ['NameInRequest'], required => 1);
has Control => (is => 'ro', isa => 'Str', request_name => 'control', traits => ['NameInRequest']);
has DecisionTaskCompletedEventId => (is => 'ro', isa => 'Int', request_name => 'decisionTaskCompletedEventId', traits => ['NameInRequest'], required => 1);
has InitiatedEventId => (is => 'ro', isa => 'Int', request_name => 'initiatedEventId', traits => ['NameInRequest'], required => 1);
has RunId => (is => 'ro', isa => 'Str', request_name => 'runId', traits => ['NameInRequest']);
has WorkflowId => (is => 'ro', isa => 'Str', request_name => 'workflowId', traits => ['NameInRequest'], required => 1);
1;
### main pod documentation begin ###
=head1 NAME
Paws::SimpleWorkflow::RequestCancelExternalWorkflowExecutionFailedEventAttributes
=head1 USAGE
This class represents one of two things:
=head3 Arguments in a call to a service
Use the attributes of this class as arguments to methods. You shouldn't make instances of this class.
Each attribute should be used as a named argument in the calls that expect this type of object.
As an example, if Att1 is expected to be a Paws::SimpleWorkflow::RequestCancelExternalWorkflowExecutionFailedEventAttributes object:
$service_obj->Method(Att1 => { Cause => $value, ..., WorkflowId => $value });
=head3 Results returned from an API call
Use accessors for each attribute. If Att1 is expected to be an Paws::SimpleWorkflow::RequestCancelExternalWorkflowExecutionFailedEventAttributes object:
$result = $service_obj->Method(...);
$result->Att1->Cause
=head1 DESCRIPTION
Provides the details of the
C<RequestCancelExternalWorkflowExecutionFailed> event.
=head1 ATTRIBUTES
=head2 B<REQUIRED> Cause => Str
The cause of the failure. This information is generated by the system
and can be useful for diagnostic purposes.
If C<cause> is set to C<OPERATION_NOT_PERMITTED>, the decision failed
because it lacked sufficient permissions. For details and example IAM
policies, see Using IAM to Manage Access to Amazon SWF Workflows
(https://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dev-iam.html)
in the I<Amazon SWF Developer Guide>.
=head2 Control => Str
The data attached to the event that the decider can use in subsequent
workflow tasks. This data isn't sent to the workflow execution.
=head2 B<REQUIRED> DecisionTaskCompletedEventId => Int
The ID of the C<DecisionTaskCompleted> event corresponding to the
decision task that resulted in the
C<RequestCancelExternalWorkflowExecution> decision for this
cancellation request. This information can be useful for diagnosing
problems by tracing back the chain of events leading up to this event.
=head2 B<REQUIRED> InitiatedEventId => Int
The ID of the C<RequestCancelExternalWorkflowExecutionInitiated> event
corresponding to the C<RequestCancelExternalWorkflowExecution> decision
to cancel this external workflow execution. This information can be
useful for diagnosing problems by tracing back the chain of events
leading up to this event.
=head2 RunId => Str
The C<runId> of the external workflow execution.
=head2 B<REQUIRED> WorkflowId => Str
The C<workflowId> of the external workflow to which the cancel request
was to be delivered.
=head1 SEE ALSO
This class forms part of L<Paws>, describing an object used in L<Paws::SimpleWorkflow>
=head1 BUGS and CONTRIBUTIONS
The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
=cut
| 34.82243 | 157 | 0.760064 |
edba7946bb269c8521ec8548968c74eee9b46de0 | 432 | pl | Perl | perl/lib/unicore/lib/Nv/30000.pl | JyothsnaMididoddi26/xampp | 8f34d7fa7c2e6cc37fe4ece5e6886dc4e5c0757b | [
"Apache-2.0"
] | 1 | 2017-01-31T08:49:16.000Z | 2017-01-31T08:49:16.000Z | xampp/perl/lib/unicore/lib/Nv/30000.pl | silent88/Biographies-du-Fontenay | af4567cb6b78003daa72c37b5ac9f5611a360a9f | [
"MIT"
] | 2 | 2020-07-17T00:13:41.000Z | 2021-05-08T17:01:54.000Z | perl/lib/unicore/lib/Nv/30000.pl | Zolhyp/Plan | 05dbf6a650cd54f855d1731dee70098c5c587339 | [
"Apache-2.0"
] | null | null | null | # !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
# This file is machine-generated by mktables from the Unicode
# database, Version 6.1.0. Any changes made here will be lost!
# !!!!!!! INTERNAL PERL USE ONLY !!!!!!!
# This file is for internal use by core Perl only. The format and even the
# name or existence of this file are subject to change without notice. Don't
# use it directly.
return <<'END';
1012D
END
| 30.857143 | 78 | 0.645833 |
ed5a209021128c35051e00eac59341e6a52c8d2f | 2,959 | t | Perl | t/204-T-Basic-all.t | dallaylaen/p5-Refute | 8590b9da717b6e0af352a4a204158cf3b54f2294 | [
"Artistic-2.0",
"Unlicense"
] | null | null | null | t/204-T-Basic-all.t | dallaylaen/p5-Refute | 8590b9da717b6e0af352a4a204158cf3b54f2294 | [
"Artistic-2.0",
"Unlicense"
] | null | null | null | t/204-T-Basic-all.t | dallaylaen/p5-Refute | 8590b9da717b6e0af352a4a204158cf3b54f2294 | [
"Artistic-2.0",
"Unlicense"
] | null | null | null | #!/usr/bin/env perl
use strict;
use warnings;
use Test::More;
use Refute qw(refute_and_report);
{
# Be extra careful not to pollute the main namespace
package T;
use Refute qw(:all);
};
my $report;
$report = refute_and_report {
package T;
pass 'foo';
};
is $report->get_sign, "t1d", "pass()";
note $report->get_tap;
$report = refute_and_report {
package T;
fail 'foo';
};
is $report->get_sign, "tNd", "fail()";
note $report->get_tap;
$report = refute_and_report {
package T;
is 42, 42;
is 42, 137;
is undef, '';
is '', undef;
is undef, undef;
is "foo", "foo";
is "foo", "bar";
is {}, [];
is {}, {}, "different struct";
my @x = 1..5;
my @y = 11..15;
is @x, @y, "scalar context";
};
is $report->get_sign, "t1NNN2NNN1d", "is()";
note $report->get_tap;
$report = refute_and_report {
package T;
isnt 42, 137;
isnt 42, 42;
isnt undef, undef;
isnt undef, 42;
isnt 42, undef;
isnt '', undef;
isnt undef, '';
};
is $report->get_sign, "t1NN4d", "isnt()";
note $report->get_tap;
$report = refute_and_report {
package T;
like "foo", qr/oo*/;
like "foo", "oo*";
like "foo", qr/bar/;
like "foo", "f.*o";
like undef, qr/.*/;
};
is $report->get_sign, "t1NN1Nd", "like()";
note $report->get_tap;
$report = refute_and_report {
package T;
unlike "foo", qr/bar/;
unlike "foo", qr/foo/;
unlike "foo", "oo*";
unlike "foo", "f.*o";
unlike undef, qr/.*/;
};
is $report->get_sign, "t1N1NNd", "unlike()";
note $report->get_tap;
$report = refute_and_report {
package T;
ok ok 1;
ok ok 0;
ok undef;
};
is $report->get_sign, "t2NNNd", "ok()";
note $report->get_tap;
$report = refute_and_report {
package T;
not_ok 0, "dummy";
not_ok { foo => 42 }, "dummy";
};
is $report->get_sign, "t1Nd", "not_ok()";
note $report->get_tap;
$report = refute_and_report {
package TT;
our @ISA = 'T';
package T;
isa_ok current_contract, "Refute::Report";
isa_ok current_contract, "Foo::Bar";
isa_ok "TT", "T";
isa_ok "TT", "Foo::Bar";
};
is $report->get_sign, "t1N1Nd", "isa_ok()";
note $report->get_tap;
$report = refute_and_report {
package T;
can_ok current_contract, "can_ok";
can_ok current_contract, "frobnicate";
can_ok "Refute", "import", "can_ok";
can_ok "Refute", "unknown_subroutine";
can_ok "No::Exist", "can", "isa", "import";
};
is $report->get_sign, "t1N1NNd", "can_ok()";
note $report->get_tap;
$report = refute_and_report {
# TODO write a better new_ok
package T;
new_ok "Refute::Report", [];
new_ok "No::Such::Package", [];
};
is $report->get_sign, "t1Nd", "new_ok()";
note $report->get_tap;
$report = refute_and_report {
package T;
require_ok "Refute"; # already loaded
require_ok "No::Such::Package::_______::000";
};
is $report->get_sign, "t1Nd", "require_ok()";
note $report->get_tap;
done_testing;
| 20.838028 | 56 | 0.595133 |
edca16af5f3988f1492eb8cea1f098b776b091df | 2,945 | pm | Perl | lib/Cfn/Resource/AWS/EC2/SecurityGroupEgress.pm | agimenez/cfn-perl | 66eaffd2044b6a4921b43183f7b6b20aaa46b24a | [
"Apache-2.0"
] | null | null | null | lib/Cfn/Resource/AWS/EC2/SecurityGroupEgress.pm | agimenez/cfn-perl | 66eaffd2044b6a4921b43183f7b6b20aaa46b24a | [
"Apache-2.0"
] | 22 | 2019-02-14T16:50:38.000Z | 2022-02-08T11:50:46.000Z | lib/Cfn/Resource/AWS/EC2/SecurityGroupEgress.pm | agimenez/cfn-perl | 66eaffd2044b6a4921b43183f7b6b20aaa46b24a | [
"Apache-2.0"
] | 5 | 2019-02-15T11:43:28.000Z | 2022-03-20T18:34:34.000Z | # AWS::EC2::SecurityGroupEgress generated from spec 14.3.0
use Moose::Util::TypeConstraints;
coerce 'Cfn::Resource::Properties::AWS::EC2::SecurityGroupEgress',
from 'HashRef',
via { Cfn::Resource::Properties::AWS::EC2::SecurityGroupEgress->new( %$_ ) };
package Cfn::Resource::AWS::EC2::SecurityGroupEgress {
use Moose;
extends 'Cfn::Resource';
has Properties => (isa => 'Cfn::Resource::Properties::AWS::EC2::SecurityGroupEgress', is => 'rw', coerce => 1);
sub AttributeList {
[ ]
}
sub supported_regions {
[ 'af-south-1','ap-east-1','ap-northeast-1','ap-northeast-2','ap-northeast-3','ap-south-1','ap-southeast-1','ap-southeast-2','ca-central-1','cn-north-1','cn-northwest-1','eu-central-1','eu-north-1','eu-south-1','eu-west-1','eu-west-2','eu-west-3','me-south-1','sa-east-1','us-east-1','us-east-2','us-gov-east-1','us-gov-west-1','us-west-1','us-west-2' ]
}
}
package Cfn::Resource::Properties::AWS::EC2::SecurityGroupEgress {
use Moose;
use MooseX::StrictConstructor;
extends 'Cfn::Resource::Properties';
has CidrIp => (isa => 'Cfn::Value::String', is => 'rw', coerce => 1, traits => [ 'CfnMutability' ], mutability => 'Immutable');
has CidrIpv6 => (isa => 'Cfn::Value::String', is => 'rw', coerce => 1, traits => [ 'CfnMutability' ], mutability => 'Immutable');
has Description => (isa => 'Cfn::Value::String', is => 'rw', coerce => 1, traits => [ 'CfnMutability' ], mutability => 'Mutable');
has DestinationPrefixListId => (isa => 'Cfn::Value::String', is => 'rw', coerce => 1, traits => [ 'CfnMutability' ], mutability => 'Immutable');
has DestinationSecurityGroupId => (isa => 'Cfn::Value::String', is => 'rw', coerce => 1, traits => [ 'CfnMutability' ], mutability => 'Immutable');
has FromPort => (isa => 'Cfn::Value::Integer', is => 'rw', coerce => 1, traits => [ 'CfnMutability' ], mutability => 'Immutable');
has GroupId => (isa => 'Cfn::Value::String', is => 'rw', coerce => 1, required => 1, traits => [ 'CfnMutability' ], mutability => 'Immutable');
has IpProtocol => (isa => 'Cfn::Value::String', is => 'rw', coerce => 1, required => 1, traits => [ 'CfnMutability' ], mutability => 'Immutable');
has ToPort => (isa => 'Cfn::Value::Integer', is => 'rw', coerce => 1, traits => [ 'CfnMutability' ], mutability => 'Immutable');
}
1;
### main pod documentation begin ###
=encoding UTF-8
=head1 NAME
Cfn::Resource::AWS::EC2::SecurityGroupEgress - Cfn resource for AWS::EC2::SecurityGroupEgress
=head1 DESCRIPTION
This module implements a Perl module that represents the CloudFormation object AWS::EC2::SecurityGroupEgress.
See L<Cfn> for more information on how to use it.
=head1 AUTHOR
Jose Luis Martinez
CAPSiDE
[email protected]
=head1 COPYRIGHT and LICENSE
Copyright (c) 2013 by CAPSiDE
This code is distributed under the Apache 2 License. The full text of the
license can be found in the LICENSE file included with this module.
=cut
| 43.955224 | 357 | 0.657046 |
73d72a5dc5f586e2d9c713bde25799db37900d67 | 30,877 | pl | Perl | files/check_unix_mem_usage.pl | addia/puppet-nagiosclient | 8ed0e7e2d78ea2fae8d9704ef3ab3dbbf46ddfbc | [
"MIT"
] | null | null | null | files/check_unix_mem_usage.pl | addia/puppet-nagiosclient | 8ed0e7e2d78ea2fae8d9704ef3ab3dbbf46ddfbc | [
"MIT"
] | null | null | null | files/check_unix_mem_usage.pl | addia/puppet-nagiosclient | 8ed0e7e2d78ea2fae8d9704ef3ab3dbbf46ddfbc | [
"MIT"
] | null | null | null | #!/usr/bin/perl -w
# check_mem_usage Nagios Plugin
#
# TComm - Carlos Peris Pla
#
# This nagios plugin is free software, and comes with ABSOLUTELY
# NO WARRANTY. It may be used, redistributed and/or modified under
# the terms of the GNU General Public Licence (see
# http://www.fsf.org/licensing/licenses/gpl.txt).
# MODULE DECLARATION
use strict;
use Nagios::Plugin;
# FUNCTION DECLARATION
sub CreateNagiosManager ();
sub CheckArguments ();
sub PerformCheck ();
sub UnitConversion ();
sub ConversionFromPercentage ();
sub PerfdataToBytes ();
# CONSTANT DEFINITION
use constant NAME => 'check_unix_mem_usage';
use constant VERSION => '0.4b';
use constant USAGE => "Usage:\ncheck_unix_mem_usage -w <mem_threshold,app_mem_threshold,cache_threshold,swap_threshold> -c <mem_threshold,app_mem_threshold,cache_threshold,swap_threshold>\n".
"\t\t[-u <unit>] [-m <maxram>] [-p <perthres>] \n".
"\t\t[-V <version>]\n";
use constant BLURB => "This plugin checks the memory status of a UNIX system and compares the values of memory usage,\n".
"application memory usage and swap with their associated thresholds.\n";
use constant LICENSE => "This nagios plugin is free software, and comes with ABSOLUTELY\n".
"no WARRANTY. It may be used, redistributed and/or modified under\n".
"the terms of the GNU General Public Licence\n".
"(see http://www.fsf.org/licensing/licenses/gpl.txt).\n";
use constant EXAMPLE => "\n\n".
"Examples:\n".
"\n".
"check_unix_mem_usage.pl -u MiB -w 900,800,400,700 -c 1000,900,500,800\n".
"\n".
"It returns WARNING if memory usage is higher than 900MiB or if application memory usage is higher than 800MiB or\n".
"if cache usage is higher than 400MiB or if used swap is higher than 700MiB and CRITICAL if memory usage is higher\n".
"than 1000MiB or if application memory usage is higher than 900MiB or if cache usage is higher than 500MiB or if \n".
"used swap is higher than 800MiB.\n".
"In other cases it returns OK if check has been performed succesfully.\n\n".
"Note: thresholds of both WARNING and CRITICAL must be passed in the chosen units.\n".
"\n\n".
"check_unix_mem_usage.pl -u MiB -m -p -w 80,80,,80 -c 90,90,,90\n".
"\n".
"It returns WARNING if memory usage or if application memory usage or if swap is higher than 80% and CRITICAL if \n".
"memory usage or if application memory usage or if swap is higher than 90%.\n".
"In other cases it returns OK if check has been performed succesfully.\n\n".
"Note: thresholds of both WARNING and CRITICAL must be passed in percentage. And note that the cache has not been\n".
"checked.\n";
# VARIABLE DEFINITION
my $Nagios;
my $Error;
my $PluginResult;
my $PluginOutput;
my @WVRange;
my @CVRange;
my $Unit;
my $ConvertToUnit=0;
my @MemFLAGS=(1,1);
my @AppFLAGS=(1,1);
my @CacheFLAGS=(1,1);
my @SwapFLAGS=(1,1);
# MAIN FUNCTION
# Get command line arguments
$Nagios = &CreateNagiosManager(USAGE, VERSION, BLURB, LICENSE, NAME, EXAMPLE);
eval {$Nagios->getopts};
if (!$@) {
# Command line parsed
if (&CheckArguments($Nagios, \$Error, \$Unit, \$ConvertToUnit, \@WVRange, \@CVRange)) {
# Argument checking passed
$PluginResult = &PerformCheck($Nagios, \$PluginOutput, $Unit, $ConvertToUnit, \@WVRange, \@CVRange)
}
else {
# Error checking arguments
$PluginOutput = $Error;
$PluginResult = UNKNOWN;
}
$Nagios->nagios_exit($PluginResult,$PluginOutput);
}
else {
# Error parsing command line
$Nagios->nagios_exit(UNKNOWN,$@);
}
# FUNCTION DEFINITIONS
# Creates and configures a Nagios plugin object
# Input: strings (usage, version, blurb, license, name and example) to configure argument parsing functionality
# Return value: reference to a Nagios plugin object
sub CreateNagiosManager() {
# Create GetOpt object
my $Nagios = Nagios::Plugin->new(usage => $_[0], version => $_[1], blurb => $_[2], license => $_[3], plugin => $_[4], extra => $_[5]);
# Add argument units
$Nagios->add_arg(spec => 'units|u=s',
help => 'Output units based on IEEE 1541 standard. By default in percentage value. Format: unit (default: %)',
default => '%',
required => 0);
# Add argument percentage threshold
$Nagios->add_arg(spec => 'perthres|p',
help => 'Warning and critical thresholds in percentage.',
required => 0);
# Add argument maxram
$Nagios->add_arg(spec => 'maxram|m',
help => 'Show the MaxRam value in perfdata.',
required => 0);
# Add argument warning
$Nagios->add_arg(spec => 'warning|w=s',
help => "Warning threshold (using selected unit as magnitude). Format: <mem_threshold,app_mem_threshold,cache_threshold,swap_threshold>",
required => 1);
# Add argument critical
$Nagios->add_arg(spec => 'critical|c=s',
help => "Critical threshold (using selected unit as magnitude). Format: <mem_threshold,app_mem_threshold,cache_threshold,swap_threshold>",
required => 1);
# Return value
return $Nagios;
}
# Checks argument values and sets some default values
# Input: Nagios Plugin object
# Output: reference to Error description string, Memory Unit, Swap Unit, reference to WVRange ($_[4]), reference to CVRange ($_[5])
# Return value: True if arguments ok, false if not
sub CheckArguments() {
my ($Nagios, $Error, $Unit, $ConvertToUnit, $WVRange, $CVRange) = @_;
my $commas;
my $units;
my $i;
my $firstpos;
my $secondpos;
my $flag;
# Check units list
$units = $Nagios->opts->units;
if ($units eq "") {
${$Unit} = "%";
}
elsif (!($units =~ /^((B)|(KiB)|(MiB)|(GiB)|(TiB)|(%))$/)){
${$Error} = "Invalid unit in $units, this must to be percentage or a unit expressed under the IEEE 1541 standard.";
return 0;
}
else {
${$Unit} = $units;
}
# Check argument perthres
if (defined($Nagios->opts->perthres)){
${ConvertToUnit} = 1;
}
# Check Warning thresholds list
$commas = $Nagios->opts->warning =~ tr/,//;
if ($commas !=3){
${$Error} = "Invalid Warning list format. Three commas are expected.";
return 0;
}
else{
$i=0;
$firstpos=0;
my $warning=$Nagios->opts->warning;
while ($warning =~ /[,]/g) {
$secondpos=pos $warning;
if ($secondpos - $firstpos==1){
@{$WVRange}[$i] = "~:";
&FlagSet(0, $i)
}
else{
@{$WVRange}[$i] = substr $Nagios->opts->warning, $firstpos, ($secondpos-$firstpos-1);
}
$firstpos=$secondpos;
$i++
}
if (length($Nagios->opts->warning) - $firstpos==0){#La coma es el ultimo elemento del string
@{$WVRange}[$i] = "~:";
&FlagSet(0, $i)
}
else{
@{$WVRange}[$i] = substr $Nagios->opts->warning, $firstpos, (length($Nagios->opts->warning)-$firstpos);
}
if (@{$WVRange}[0] !~/^(@?(\d+(\.\d+)?|(\d+|~):(\d+(\.\d+)?)?))?$/){
${$Error} = "Invalid Memory Warning threshold in @{$WVRange}[0]";
return 0;
}if (@{$WVRange}[1] !~/^(@?(\d+(\.\d+)?|(\d+|~):(\d+(\.\d+)?)?))?$/){
${$Error} = "Invalid Application Memory Warning threshold in @{$WVRange}[1]";
return 0;
}
if (@{$WVRange}[2] !~/^(@?(\d+(\.\d+)?|(\d+|~):(\d+(\.\d+)?)?))?$/){
${$Error} = "Invalid Cache Warning threshold in @{$WVRange}[2]";
return 0;
}
if (@{$WVRange}[3] !~/^(@?(\d+(\.\d+)?|(\d+|~):(\d+(\.\d+)?)?))?$/){
${$Error} = "Invalid Swap Warning threshold in @{$WVRange}[3]";
return 0;
}
}
# Check Critical thresholds list
$commas = $Nagios->opts->critical =~ tr/,//;
if ($commas !=3){
${$Error} = "Invalid Critical list format. Three commas are expected.";
return 0;
}
else{
$i=0;
$firstpos=0;
my $critical=$Nagios->opts->critical;
while ($critical =~ /[,]/g) {
$secondpos=pos $critical ;
if ($secondpos - $firstpos==1){
@{$CVRange}[$i] = "~:";
&FlagSet(1, $i)
}
else{
@{$CVRange}[$i] =substr $Nagios->opts->critical, $firstpos, ($secondpos-$firstpos-1);
}
$firstpos=$secondpos;
$i++
}
if (length($Nagios->opts->critical) - $firstpos==0){#La coma es el ultimo elemento del string
@{$CVRange}[$i] = "~:";
&FlagSet(1, $i)
}
else{
@{$CVRange}[$i] = substr $Nagios->opts->critical, $firstpos, (length($Nagios->opts->critical)-$firstpos);
}
if (@{$CVRange}[0] !~/^(@?(\d+(\.\d+)?|(\d+|~):(\d+(\.\d+)?)?))?$/) {
${$Error} = "Invalid Critical threshold in @{$CVRange}[0]";
return 0;
}
if (@{$CVRange}[1] !~/^(@?(\d+(\.\d+)?|(\d+|~):(\d+(\.\d+)?)?))?$/) {
${$Error} = "Invalid Application Critical threshold in @{$CVRange}[1]";
return 0;
}
if (@{$CVRange}[2] !~/^(@?(\d+(\.\d+)?|(\d+|~):(\d+(\.\d+)?)?))?$/) {
${$Error} = "Invalid Cache Critical threshold in @{$CVRange}[2]";
return 0;
}
if (@{$CVRange}[3] !~/^(@?(\d+(\.\d+)?|(\d+|~):(\d+(\.\d+)?)?))?$/) {
${$Error} = "Invalid Swap Critical threshold in @{$CVRange}[3]";
return 0;
}
}
return 1;
}
# Set the value of the flag to indicate that the values are to be checked
# Input: Warning(0) or Critical(1), Mem
sub FlagSet() {
my ($WoC, $Mem) = @_;
if ($Mem == 0) {
$MemFLAGS[$WoC] = 0;
}
elsif ($Mem == 1) {
$AppFLAGS[$WoC] = 0;
}
elsif ($Mem == 2) {
$CacheFLAGS[$WoC] = 0;
}
elsif ($Mem == 3) {
$SwapFLAGS[$WoC] = 0;
}
}
# Performs whole check:
# Input: Nagios Plugin object, reference to Plugin output string, Memory Unit, Swap Unit, referece to WVRange, reference to CVRange
# Output: Plugin output string
# Return value: Plugin return value
sub PerformCheck() {
my ($Nagios, $PluginOutput, $Unit, $ConvertToUnit, $WVRange, $CVRange) = @_;
my @Request;
my $ProcMeminfo;
my $Line;
my @DataInLine;
my $MemTotal;
my $MaxRam;
my $MemFree;
my $MemUsed;
my $MemPercentageUsed;
my $MemUsedPerfdata;
my $MemWarningPerfdata;
my $MemCriticalPerfdata;
my $MemMaxPerfdata;
my $Buffers;
my $SwapCached;
my $CacheTotal;
my $CacheFree = 0;
my $CacheUsed;
my $CachePercentageUsed;
my $CacheUsedPerfdata;
my $CacheWarningPerfdata;
my $CacheCriticalPerfdata;
my $CacheMaxPerfdata;
my $AppMemTotal;
my $AppMemFree;
my $AppMemUsed;
my $AppMemPercentageUsed;
my $AppMemUsedPerfdata;
my $AppMemWarningPerfdata;
my $AppMemCriticalPerfdata;
my $AppMemMaxPerfdata;
my $SwapTotal;
my $SwapFree;
my $SwapUsed;
my $SwapPercentageUsed;
my $SwapUsedPerfdata;
my $SwapWarningPerfdata;
my $SwapCriticalPerfdata;
my $SwapMaxPerfdata;
my $Colons;
my $i;
my $firstpos;
my $secondpos;
my $threshold;
my @ThresholdLevels;
my $MinPerfdata = 0;
my $PerformanceData="";
my $MemPluginOutput = "";
my $AppMemPluginOutput = "";
my $CachePluginOutput = "";
my $SwapPluginOutput = "";
my $PluginReturnValue = UNKNOWN;
my $MemPluginReturnValue;
my $AppMemPluginReturnValue;
my $CachePluginReturnValue;
my $SwapPluginReturnValue;
my $OkFlag = 0;
my $WarningFlag = 0;
my $CriticalFlag = 0;
${$PluginOutput}="";
# Recovering status memory values
$ProcMeminfo = "/proc/meminfo";
open(PROCMEMINFO, $ProcMeminfo);
while (<PROCMEMINFO>) {
$Line = $_;
chomp($Line);
$Line =~ s/ //g;
@DataInLine = split(/:/, $Line);
if ($DataInLine[0] eq 'MemTotal') {
if( length($DataInLine[1]) > 2) { $MemTotal = substr($DataInLine[1], 0, length($DataInLine[1])-2); }
else { $MemTotal = $DataInLine[1]; }
$MaxRam = $MemTotal * 1024.0; # The MaxRam in Bytes
}
if ($DataInLine[0] eq 'MemFree') {
if( length($DataInLine[1]) > 2) { $MemFree = substr($DataInLine[1], 0, length($DataInLine[1])-2); }
else { $MemFree = $DataInLine[1]; }
}
if ($DataInLine[0] eq 'Buffers') {
if( length($DataInLine[1]) > 2) { $Buffers = substr($DataInLine[1], 0, length($DataInLine[1])-2); }
else { $Buffers = $DataInLine[1]; }
}
if ($DataInLine[0] eq 'Cached') {
if( length($DataInLine[1]) > 2) { $CacheUsed = substr($DataInLine[1], 0, length($DataInLine[1])-2); }
else { $CacheUsed = $DataInLine[1]; }
}
if ($DataInLine[0] eq 'SwapCached') {
if( length($DataInLine[1]) > 2) { $SwapCached = substr($DataInLine[1], 0, length($DataInLine[1])-2); }
else { $SwapCached = $DataInLine[1]; }
}
if ($DataInLine[0] eq 'SwapTotal') {
if( length($DataInLine[1]) > 2) { $SwapTotal = substr($DataInLine[1], 0, length($DataInLine[1])-2); }
else { $SwapTotal = $DataInLine[1]; }
}
if ($DataInLine[0] eq 'SwapFree') {
if( length($DataInLine[1]) > 2) { $SwapFree = substr($DataInLine[1], 0, length($DataInLine[1])-2); }
else { $SwapFree = $DataInLine[1]; }
}
}
close PROCMEMINFO;
# Memory
$MemUsed = $MemTotal - $MemFree;
# Cache
$CacheTotal = $MemTotal;
# Memory used by Applications
$AppMemTotal = $MemTotal * 0.95;
$AppMemUsed = $MemUsed - ($Buffers + $CacheUsed + $SwapCached);
$AppMemFree = $AppMemTotal - $AppMemUsed;
# Swap
$SwapUsed = $SwapTotal - $SwapFree;
# Applying units (the values are recovered in KiB)
# Memory:
$MemPercentageUsed = &UnitConversion($Unit, \$MemTotal, \$MemFree, \$MemUsed);
# If thresholds in percentage and units not in percentage convert thresholds in units
if (defined($Nagios->opts->perthres)) {
(@{$WVRange}[0], @{$CVRange}[0]) = &ConversionFromPercentage($Unit, $MemTotal, @{$WVRange}[0], @{$CVRange}[0]);
}
($MemUsedPerfdata, $MemWarningPerfdata, $MemCriticalPerfdata, $MemMaxPerfdata) = &PerfdataToBytes($Unit, $MemTotal, $MemFree, $MemUsed, @{$WVRange}[0], @{$CVRange}[0]);
# Memory used by Applications:
$AppMemPercentageUsed = &UnitConversion($Unit, \$AppMemTotal, \$AppMemFree, \$AppMemUsed);
# If thresholds in percentage and units not in percentage convert thresholds in units
if (defined($Nagios->opts->perthres)) {
(@{$WVRange}[1], @{$CVRange}[1]) = &ConversionFromPercentage($Unit, $AppMemTotal, @{$WVRange}[1], @{$CVRange}[1]);
}
($AppMemUsedPerfdata, $AppMemWarningPerfdata, $AppMemCriticalPerfdata, $AppMemMaxPerfdata) = &PerfdataToBytes($Unit, $AppMemTotal, $AppMemFree, $AppMemUsed, @{$WVRange}[1], @{$CVRange}[1]);
# Cache:
$CachePercentageUsed = &UnitConversion($Unit, \$CacheTotal, \$CacheFree, \$CacheUsed);
# If thresholds in percentage and units not in percentage convert thresholds in units
if (defined($Nagios->opts->perthres)) {
(@{$WVRange}[2], @{$CVRange}[2]) = &ConversionFromPercentage($Unit, $CacheTotal, @{$WVRange}[2], @{$CVRange}[2]);
}
($CacheUsedPerfdata, $CacheWarningPerfdata, $CacheCriticalPerfdata, $CacheMaxPerfdata) = &PerfdataToBytes($Unit, $CacheTotal, $CacheFree, $CacheUsed, @{$WVRange}[2], @{$CVRange}[2]);
# Swap:
$SwapPercentageUsed = &UnitConversion($Unit, \$SwapTotal, \$SwapFree, \$SwapUsed);
# If thresholds in percentage and units not in percentage convert thresholds in units
if (defined($Nagios->opts->perthres)) {
(@{$WVRange}[3], @{$CVRange}[3]) = &ConversionFromPercentage($Unit, $SwapTotal, @{$WVRange}[3], @{$CVRange}[3]);
}
($SwapUsedPerfdata, $SwapWarningPerfdata, $SwapCriticalPerfdata, $SwapMaxPerfdata) = &PerfdataToBytes($Unit, $SwapTotal, $SwapFree, $SwapUsed, @{$WVRange}[3], @{$CVRange}[3]);
if ($MemFLAGS[0] || $MemFLAGS[1]) {
# Adding (only) memory status to MemPluginOutput
$MemUsed = sprintf("%.2f", $MemUsed);
$MemPercentageUsed = sprintf("%.2f", $MemPercentageUsed);
$MemTotal = sprintf("%.2f", $MemTotal);
if ($Unit ne "%") {
$MemPluginOutput .= "Memory usage: $MemUsed$Unit ($MemPercentageUsed%) of $MemTotal$Unit";
}
else {
$MemPluginOutput .= "Memory usage: $MemUsed$Unit";
}
}
if ($AppFLAGS[0] || $AppFLAGS[1]) {
# Adding (only) applications memory status to AppMemPluginOutput
$AppMemUsed = sprintf("%.2f", $AppMemUsed);
$AppMemPercentageUsed = sprintf("%.2f", $AppMemPercentageUsed);
$AppMemTotal = sprintf("%.2f", $AppMemTotal);
if ($Unit ne "%") {
$AppMemPluginOutput .= "Application memory usage: $AppMemUsed$Unit ($AppMemPercentageUsed%) of $AppMemTotal$Unit";
}
else {
$AppMemPluginOutput .= "Application memory usage: $AppMemUsed$Unit";
}
}
if ($CacheFLAGS[0] || $CacheFLAGS[1]){
# Adding cache status to CachePluginOutput
$CacheUsed = sprintf("%.2f", $CacheUsed);
$CachePercentageUsed = sprintf("%.2f", $CachePercentageUsed);
$CacheTotal = sprintf("%.2f", $CacheTotal);
if ($Unit ne "%") {
$CachePluginOutput .= "Cache usage: $CacheUsed$Unit ($CachePercentageUsed%) of $CacheTotal$Unit";
}
else {
$CachePluginOutput .= "Cache usage: $CacheUsed$Unit";
}
}
if ($SwapFLAGS[0] || $SwapFLAGS[1]) {
# Adding swap status to SwapPluginOutput
$SwapUsed = sprintf("%.2f", $SwapUsed);
$SwapPercentageUsed = sprintf("%.2f", $SwapPercentageUsed);
$SwapTotal = sprintf("%.2f", $SwapTotal);
if ($Unit ne "%") {
$SwapPluginOutput .= "Swap usage: $SwapUsed$Unit ($SwapPercentageUsed%) of $SwapTotal$Unit";
}
else {
$SwapPluginOutput .= "Swap usage: $SwapUsed$Unit";
}
}
if ($MemFLAGS[0] || $MemFLAGS[1]) {
# Checking Memory State
$MemPluginReturnValue = $Nagios->check_threshold(check => $MemUsed,warning => @{$WVRange}[0],critical => @{$CVRange}[0]);
if ($MemPluginReturnValue eq OK){
$OkFlag = 1;
$MemPluginOutput .= ", ";
}
elsif ($MemPluginReturnValue eq WARNING) {
$MemPluginOutput .= " (warning threshold is set to @{$WVRange}[0]$Unit), ";
$WarningFlag = 1;
}
elsif ($MemPluginReturnValue eq CRITICAL) {
$MemPluginOutput .= " (critical threshold is set to @{$CVRange}[0]$Unit), ";
$CriticalFlag = 1;
}
}
if ($AppFLAGS[0] || $AppFLAGS[1]) {
# Checking Applications Memory State
$AppMemPluginReturnValue = $Nagios->check_threshold(check => $AppMemUsed,warning => @{$WVRange}[1],critical => @{$CVRange}[1]);
if ($AppMemPluginReturnValue eq OK){
$OkFlag = 1;
$AppMemPluginOutput .= ", ";
}
elsif ($AppMemPluginReturnValue eq WARNING) {
$AppMemPluginOutput .= " (warning threshold is set to @{$WVRange}[1]$Unit), ";
$WarningFlag = 1;
}
elsif ($AppMemPluginReturnValue eq CRITICAL) {
$AppMemPluginOutput .= " (critical threshold is set to @{$CVRange}[1]$Unit), ";
$CriticalFlag = 1;
}
}
if ($CacheFLAGS[0] || $CacheFLAGS[1]){
# Checking Cache State
$CachePluginReturnValue = $Nagios->check_threshold(check => $CacheUsed,warning => @{$WVRange}[2],critical => @{$CVRange}[2]);
if ($CachePluginReturnValue eq OK){
$OkFlag = 1;
$CachePluginOutput .= ", ";
}
elsif ($CachePluginReturnValue eq WARNING) {
$CachePluginOutput .= " (warning threshold is set to @{$WVRange}[2]), ";
$WarningFlag = 1;
}
elsif ($CachePluginReturnValue eq CRITICAL) {
$CachePluginOutput .= " (critical threshold is set to @{$CVRange}[2]$Unit), ";
$CriticalFlag = 1;
}
}
if ($SwapFLAGS[0] || $SwapFLAGS[1]) {
# Checking Swap State
$SwapPluginReturnValue = $Nagios->check_threshold(check => $SwapUsed,warning => @{$WVRange}[3],critical => @{$CVRange}[3]);
if ($SwapPluginReturnValue eq OK){
$OkFlag = 1;
$SwapPluginOutput .= ", ";
}
elsif ($SwapPluginReturnValue eq WARNING) {
$SwapPluginOutput .= " (warning threshold is set to @{$WVRange}[3]), ";
$WarningFlag = 1;
}
elsif ($SwapPluginReturnValue eq CRITICAL) {
$SwapPluginOutput .= " (critical threshold is set to @{$CVRange}[3]$Unit), ";
$CriticalFlag = 1;
}
}
# Establishing PluginReturnValue
if ($CriticalFlag) {
$PluginReturnValue = CRITICAL;
}
elsif ($WarningFlag) {
$PluginReturnValue = WARNING;
}
elsif ($OkFlag) {
$PluginReturnValue = OK;
}
# Adding Memory status tu PluginOutput
#${$PluginOutput} .= "$MemPluginOutput$AppMemPluginOutput$CachePluginOutput$SwapPluginOutput";
if ($MemFLAGS[0] || $MemFLAGS[1]) { ${$PluginOutput} .= "$MemPluginOutput"; }
if ($AppFLAGS[0] || $AppFLAGS[1]) { ${$PluginOutput} .= "$AppMemPluginOutput"; }
if ($CacheFLAGS[0] || $CacheFLAGS[1]){ ${$PluginOutput} .= "$CachePluginOutput"; }
if ($SwapFLAGS[0] || $SwapFLAGS[1]) { ${$PluginOutput} .= "$SwapPluginOutput"; }
# Adding Performance data to PerformanceData
if ($MemFLAGS[0] || $MemFLAGS[1]) {
# Memory performance data
$PerformanceData .= "MemUsed=$MemUsedPerfdata";
if ($Unit eq '%') {
$PerformanceData .= "%;";
}
else {
$PerformanceData .= "B;";
}
$PerformanceData .= "$MemWarningPerfdata;$MemCriticalPerfdata;$MinPerfdata;$MemMaxPerfdata";
}
if ($AppFLAGS[0] || $AppFLAGS[1]) {
# Performance data of the Memory used by Applications
$PerformanceData .= " AppMemUsed=$AppMemUsedPerfdata";
if ($Unit eq '%') {
$PerformanceData .= "%;";
}
else {
$PerformanceData .= "B;";
}
$PerformanceData .= "$AppMemWarningPerfdata;$AppMemCriticalPerfdata;$MinPerfdata;$AppMemMaxPerfdata";
}
if ($CacheFLAGS[0] || $CacheFLAGS[1]){
# Cache performance data
$PerformanceData .= " CacheUsed=$CacheUsedPerfdata";
if ($Unit eq '%') {
$PerformanceData .= "%;";
}
else {
$PerformanceData .= "B;";
}
$PerformanceData .= "$CacheWarningPerfdata;$CacheCriticalPerfdata;$MinPerfdata;$CacheMaxPerfdata";
}
if ($SwapFLAGS[0] || $SwapFLAGS[1]) {
# Swap performance data
$PerformanceData .= " SwapUsed=$SwapUsedPerfdata";
if ($Unit eq '%') {
$PerformanceData .= "%;";
}
else {
$PerformanceData .= "B;";
}
$PerformanceData .= "$SwapWarningPerfdata;$SwapCriticalPerfdata;$MinPerfdata;$SwapMaxPerfdata";
}
# Max Ram performance data
if (defined($Nagios->opts->maxram)) {
if ($Unit ne '%') {
$PerformanceData .= " MaxRam=$MaxRam";
$PerformanceData .= "B";
}
}
chop( ${$PluginOutput} );
chop( ${$PluginOutput} );
# Output with performance data:
${$PluginOutput} .= " | $PerformanceData";
#${$PluginOutput} = $PluginOutput;
return $PluginReturnValue;
}
# Convierte las unidades de las variables
# Input: Unit to be converted, Total, Free, Used
# Return: Percentage used
sub UnitConversion() {
my ($UnitToConversion, $Total, $Free, $Used) = @_;
my $PercentageUsed;
my $ConversionFactor;
my $TotalDivisor = (${$Total} > 0) ? ${$Total} : 1.0;
# Calculating the percentage use
$PercentageUsed = (${$Used} * 100.0) / $TotalDivisor;
if ($UnitToConversion ne "%") {
# Applying units (the values are recovered in KiB)
if ($UnitToConversion eq "B") {
# Conversion from Kibibytes to Bytes
$ConversionFactor = 1024.0;
} # End of treatment Bytes
elsif ($UnitToConversion eq "KiB") {
$ConversionFactor = 1.0;
} # End of treatment Kibibytes
if ($UnitToConversion eq "MiB") {
# Conversion from Kibibytes to Mebibytes
$ConversionFactor = 1.0 / 1024.0;
} # End of treatment Mebibytes
if ($UnitToConversion eq "GiB") {
# Conversion from Kibibytes to Gibibytes
$ConversionFactor = 1.0 / (1024.0 * 1024.0);
} # End of treatment Gibibytes
if ($UnitToConversion eq "TiB") {
# Conversion from Kibibytes to Tebibytes
$ConversionFactor = 1.0 / (1024.0 * 1024.0 * 1024);
} # End of treatment Tebibytes
# Applying the conversion
${$Total} *= $ConversionFactor;
${$Free} *= $ConversionFactor;
${$Used} *= $ConversionFactor;
}
else {
# Conversion from Kibibytes to percentage value
${$Free} = (${$Free} * 100.0) / $TotalDivisor;
${$Used} = (${$Used} * 100.0) / $TotalDivisor;
${$Total} = 100.0;
} # End of treatment Percentage
return $PercentageUsed;
}
# Convierte las unidades de los umbrales
# Input: Unit to be converted, Total, Warning Thresholds, Critical Thresholds
# Return: Warning and Critical thresholds in units
sub ConversionFromPercentage() {
my ($Unit, $Total, $WarningThreshold, $CriticalThreshold) = @_;
my $WarningThresholdInUnits;
my $CricitalThresholdInUnits;
my $Colons;
my $i;
my $firstpos;
my $threshold;
my $secondpos;
my @ThresholdLevels;
if ($Unit ne "%") {
# Establishing both warning and critical perfdata in units
# Warning
if( $WarningThreshold ne '~:' || $WarningThreshold ne '@~:' ) {
$Colons = $WarningThreshold =~ tr/://;
if ($Colons !=1){
$WarningThresholdInUnits = ($Total * $WarningThreshold) / 100.0;
}
else {
$i=0;
$firstpos=0;
$threshold = $WarningThreshold;
while ($threshold =~ /[:]/g) {
$secondpos=pos $threshold;
if ($secondpos - $firstpos==1){
$ThresholdLevels[$i] = "";
}
else{
$ThresholdLevels[$i] = substr $WarningThreshold, $firstpos, ($secondpos-$firstpos-1);
}
$firstpos=$secondpos;
$i++
}
if (length($WarningThreshold) - $firstpos==0){#La coma es el ultimo elemento del string
$ThresholdLevels[$i] = "";
}
else{
$ThresholdLevels[$i] = substr $WarningThreshold, $firstpos, (length($WarningThreshold)-$firstpos);
}
if ($ThresholdLevels[0] ne '~' && $ThresholdLevels[0] ne '@~') {
$ThresholdLevels[0] = ($Total * $ThresholdLevels[0]) / 100.0;
}
if ($ThresholdLevels[1] ne '') {
$ThresholdLevels[1] = ($Total * $ThresholdLevels[1]) / 100.0;
}
$WarningThresholdInUnits = "$ThresholdLevels[0]:$ThresholdLevels[1]";
}
}
# Critical
if( $CriticalThreshold ne '~:' || $CriticalThreshold ne '@~:' ) {
$Colons = $CriticalThreshold =~ tr/://;
if ($Colons !=1){
$CricitalThresholdInUnits = ($Total * $CriticalThreshold) / 100.0;
}
else {
$i=0;
$firstpos=0;
$threshold = $CriticalThreshold;
while ($threshold =~ /[:]/g) {
$secondpos=pos $threshold;
if ($secondpos - $firstpos==1){
$ThresholdLevels[$i] = "";
}
else{
$ThresholdLevels[$i] = substr $CriticalThreshold, $firstpos, ($secondpos-$firstpos-1);
}
$firstpos=$secondpos;
$i++
}
if (length($CriticalThreshold) - $firstpos==0){#La coma es el ultimo elemento del string
$ThresholdLevels[$i] = "";
}
else{
$ThresholdLevels[$i] = substr $CriticalThreshold, $firstpos, (length($CriticalThreshold)-$firstpos);
}
if ($ThresholdLevels[0] ne '~' && $ThresholdLevels[0] ne '@~') {
$ThresholdLevels[0] = ($Total * $ThresholdLevels[0]) / 100.0;
}
if ($ThresholdLevels[1] ne '') {
$ThresholdLevels[1] = ($Total * $ThresholdLevels[1]) / 100.0;
}
$CricitalThresholdInUnits = "$ThresholdLevels[0]:$ThresholdLevels[1]";
}
}
}
else {
# Establishing both warning and critical perfdata
$WarningThresholdInUnits = $WarningThreshold;
$CricitalThresholdInUnits = $CriticalThreshold;
} # End of treatment Percentage
return ($WarningThresholdInUnits, $CricitalThresholdInUnits);
}
# Inicializa las variables de Perfdata en Bytes
# Input: Unit to convert from, Total, Free, Used, Warning threshold, Critical threshold
# Return: UsedPerfdata, WarningPerfdata, CriticalPerfdata, MaxPerfdata
sub PerfdataToBytes() {
my ($UnitToConvertFrom, $Total, $Free, $Used, $WarningThreshold, $CriticalThreshold) = @_;
my $ConversionFactor;
my $UsedPerfdata;
my $WarningPerfdata;
my $CriticalPerfdata;
my $MaxPerfdata;
my $Colons;
my $i;
my $firstpos;
my $threshold;
my $secondpos;
my @ThresholdLevels;
$Used = sprintf("%.2f", $Used);
if ($UnitToConvertFrom ne "%") {
# Applying units (the values are recovered in KiB)
# Performance data needed in Bytes
if ($UnitToConvertFrom eq "B") {
# Conversion from Kibibytes to Bytes
$ConversionFactor = 1.0;
} # End of treatment Bytes
elsif ($UnitToConvertFrom eq "KiB") {
$ConversionFactor = 1024.0;
} # End of treatment Kibibytes
if ($UnitToConvertFrom eq "MiB") {
# Conversion from Kibibytes to Mebibytes
$ConversionFactor = 1024.0 * 1024.0;
} # End of treatment Mebibytes
if ($UnitToConvertFrom eq "GiB") {
# Conversion from Kibibytes to Gibibytes
$ConversionFactor = 1024.0 * 1024.0 * 1024.0;
} # End of treatment Gibibytes
if ($UnitToConvertFrom eq "TiB") {
# Conversion from Kibibytes to Tebibytes
$ConversionFactor = 1024.0 * 1024.0 * 1024.0;
} # End of treatment Tebibytes
if ($UnitToConvertFrom eq "B") {
$MaxPerfdata = $Total;
$UsedPerfdata = $Used;
# Establishing both warning and critical perfdata
$WarningPerfdata = $WarningThreshold;
$CriticalPerfdata = $CriticalThreshold;
} # End of treatment Bytes
else {
$MaxPerfdata = $Total * $ConversionFactor;
$UsedPerfdata = $Used * $ConversionFactor;
# Establishing both warning and critical perfdata
# Warning
if( $WarningThreshold ne '~:' || $WarningThreshold ne '@~:' ) {
$Colons = $WarningThreshold =~ tr/://;
if ($Colons !=1){
$WarningPerfdata = $WarningThreshold * $ConversionFactor;
}
else {
$i=0;
$firstpos=0;
$threshold = $WarningThreshold;
while ($threshold =~ /[:]/g) {
$secondpos=pos $threshold;
if ($secondpos - $firstpos==1){
$ThresholdLevels[$i] = "";
}
else{
$ThresholdLevels[$i] = substr $WarningThreshold, $firstpos, ($secondpos-$firstpos-1);
}
$firstpos=$secondpos;
$i++
}
if (length($WarningThreshold) - $firstpos==0){#La coma es el ultimo elemento del string
$ThresholdLevels[$i] = "";
}
else{
$ThresholdLevels[$i] = substr $WarningThreshold, $firstpos, (length($WarningThreshold)-$firstpos);
}
if ($ThresholdLevels[0] ne '~' && $ThresholdLevels[0] ne '@~') {
$ThresholdLevels[0] *= $ConversionFactor;
}
if ($ThresholdLevels[1] ne '') {
$ThresholdLevels[1] *= $ConversionFactor;
}
$WarningPerfdata = "$ThresholdLevels[0]:$ThresholdLevels[1]";
}
}
# Critical
if( $CriticalThreshold ne '~:' || $CriticalThreshold ne '@~:' ) {
$Colons = $CriticalThreshold =~ tr/://;
if ($Colons !=1){
$CriticalPerfdata = $CriticalThreshold * $ConversionFactor;
}
else {
$i=0;
$firstpos=0;
$threshold = $CriticalThreshold;
while ($threshold =~ /[:]/g) {
$secondpos=pos $threshold;
if ($secondpos - $firstpos==1){
$ThresholdLevels[$i] = "";
}
else{
$ThresholdLevels[$i] = substr $CriticalThreshold, $firstpos, ($secondpos-$firstpos-1);
}
$firstpos=$secondpos;
$i++
}
if (length($CriticalThreshold) - $firstpos==0){#La coma es el ultimo elemento del string
$ThresholdLevels[$i] = "";
}
else{
$ThresholdLevels[$i] = substr $CriticalThreshold, $firstpos, (length($CriticalThreshold)-$firstpos);
}
if ($ThresholdLevels[0] ne '~' && $ThresholdLevels[0] ne '@~') {
$ThresholdLevels[0] *= $ConversionFactor;
}
if ($ThresholdLevels[1] ne '') {
$ThresholdLevels[1] *= $ConversionFactor;
}
$CriticalPerfdata = "$ThresholdLevels[0]:$ThresholdLevels[1]";
}
}
} # End of treatment of other
}
else {
# Conversion from Kibibytes to percentage value
# Performance data needed in percentage value
$MaxPerfdata = 100.0;
$UsedPerfdata = $Used;
# Establishing both warning and critical perfdata
$WarningPerfdata = $WarningThreshold;
$CriticalPerfdata = $CriticalThreshold;
} # End of treatment Percentage
return ($UsedPerfdata, $WarningPerfdata, $CriticalPerfdata, $MaxPerfdata);
}
| 32.536354 | 192 | 0.638663 |
edc258c11953fd6c352703e9f91ff67877476864 | 7,373 | pl | Perl | assets/PortableGit/usr/share/perl5/core_perl/unicore/lib/Gc/Cn.pl | ther3tyle/git-it-electron | d808d9ce9f95ffebe39911e57907d72f4653ff6e | [
"BSD-2-Clause"
] | 4,499 | 2015-05-08T04:02:28.000Z | 2022-03-31T20:07:15.000Z | assets/PortableGit/usr/share/perl5/core_perl/unicore/lib/Gc/Cn.pl | enterstudio/git-it-electron | b101d208e9a393e16fc4368e205275e5dfc6f63e | [
"BSD-2-Clause"
] | 261 | 2015-05-09T03:09:24.000Z | 2022-03-25T18:35:53.000Z | assets/PortableGit/usr/share/perl5/core_perl/unicore/lib/Gc/Cn.pl | enterstudio/git-it-electron | b101d208e9a393e16fc4368e205275e5dfc6f63e | [
"BSD-2-Clause"
] | 1,318 | 2015-05-09T02:16:45.000Z | 2022-03-28T11:10:01.000Z | # !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
# This file is machine-generated by lib/unicore/mktables from the Unicode
# database, Version 7.0.0. Any changes made here will be lost!
# !!!!!!! INTERNAL PERL USE ONLY !!!!!!!
# This file is for internal use by core Perl only. The format and even the
# name or existence of this file are subject to change without notice. Don't
# use it directly. Use Unicode::UCD to access the Unicode character data
# base.
return <<'END';
V1199
888
890
896
900
907
908
909
910
930
931
1328
1329
1367
1369
1376
1377
1416
1417
1419
1421
1424
1425
1480
1488
1515
1520
1525
1536
1565
1566
1806
1807
1867
1869
1970
1984
2043
2048
2094
2096
2111
2112
2140
2142
2143
2208
2227
2276
2436
2437
2445
2447
2449
2451
2473
2474
2481
2482
2483
2486
2490
2492
2501
2503
2505
2507
2511
2519
2520
2524
2526
2527
2532
2534
2556
2561
2564
2565
2571
2575
2577
2579
2601
2602
2609
2610
2612
2613
2615
2616
2618
2620
2621
2622
2627
2631
2633
2635
2638
2641
2642
2649
2653
2654
2655
2662
2678
2689
2692
2693
2702
2703
2706
2707
2729
2730
2737
2738
2740
2741
2746
2748
2758
2759
2762
2763
2766
2768
2769
2784
2788
2790
2802
2817
2820
2821
2829
2831
2833
2835
2857
2858
2865
2866
2868
2869
2874
2876
2885
2887
2889
2891
2894
2902
2904
2908
2910
2911
2916
2918
2936
2946
2948
2949
2955
2958
2961
2962
2966
2969
2971
2972
2973
2974
2976
2979
2981
2984
2987
2990
3002
3006
3011
3014
3017
3018
3022
3024
3025
3031
3032
3046
3067
3072
3076
3077
3085
3086
3089
3090
3113
3114
3130
3133
3141
3142
3145
3146
3150
3157
3159
3160
3162
3168
3172
3174
3184
3192
3200
3201
3204
3205
3213
3214
3217
3218
3241
3242
3252
3253
3258
3260
3269
3270
3273
3274
3278
3285
3287
3294
3295
3296
3300
3302
3312
3313
3315
3329
3332
3333
3341
3342
3345
3346
3387
3389
3397
3398
3401
3402
3407
3415
3416
3424
3428
3430
3446
3449
3456
3458
3460
3461
3479
3482
3506
3507
3516
3517
3518
3520
3527
3530
3531
3535
3541
3542
3543
3544
3552
3558
3568
3570
3573
3585
3643
3647
3676
3713
3715
3716
3717
3719
3721
3722
3723
3725
3726
3732
3736
3737
3744
3745
3748
3749
3750
3751
3752
3754
3756
3757
3770
3771
3774
3776
3781
3782
3783
3784
3790
3792
3802
3804
3808
3840
3912
3913
3949
3953
3992
3993
4029
4030
4045
4046
4059
4096
4294
4295
4296
4301
4302
4304
4681
4682
4686
4688
4695
4696
4697
4698
4702
4704
4745
4746
4750
4752
4785
4786
4790
4792
4799
4800
4801
4802
4806
4808
4823
4824
4881
4882
4886
4888
4955
4957
4989
4992
5018
5024
5109
5120
5789
5792
5881
5888
5901
5902
5909
5920
5943
5952
5972
5984
5997
5998
6001
6002
6004
6016
6110
6112
6122
6128
6138
6144
6159
6160
6170
6176
6264
6272
6315
6320
6390
6400
6431
6432
6444
6448
6460
6464
6465
6468
6510
6512
6517
6528
6572
6576
6602
6608
6619
6622
6684
6686
6751
6752
6781
6783
6794
6800
6810
6816
6830
6832
6847
6912
6988
6992
7037
7040
7156
7164
7224
7227
7242
7245
7296
7360
7368
7376
7415
7416
7418
7424
7670
7676
7958
7960
7966
7968
8006
8008
8014
8016
8024
8025
8026
8027
8028
8029
8030
8031
8062
8064
8117
8118
8133
8134
8148
8150
8156
8157
8176
8178
8181
8182
8191
8192
8293
8294
8306
8308
8335
8336
8349
8352
8382
8400
8433
8448
8586
8592
9211
9216
9255
9280
9291
9312
11124
11126
11158
11160
11194
11197
11209
11210
11218
11264
11311
11312
11359
11360
11508
11513
11558
11559
11560
11565
11566
11568
11624
11631
11633
11647
11671
11680
11687
11688
11695
11696
11703
11704
11711
11712
11719
11720
11727
11728
11735
11736
11743
11744
11843
11904
11930
11931
12020
12032
12246
12272
12284
12288
12352
12353
12439
12441
12544
12549
12590
12593
12687
12688
12731
12736
12772
12784
12831
12832
13055
13056
19894
19904
40909
40960
42125
42128
42183
42192
42540
42560
42654
42655
42744
42752
42895
42896
42926
42928
42930
42999
43052
43056
43066
43072
43128
43136
43205
43214
43226
43232
43260
43264
43348
43359
43389
43392
43470
43471
43482
43486
43519
43520
43575
43584
43598
43600
43610
43612
43715
43739
43767
43777
43783
43785
43791
43793
43799
43808
43815
43816
43823
43824
43872
43876
43878
43968
44014
44016
44026
44032
55204
55216
55239
55243
55292
55296
64110
64112
64218
64256
64263
64275
64280
64285
64311
64312
64317
64318
64319
64320
64322
64323
64325
64326
64450
64467
64832
64848
64912
64914
64968
65008
65022
65024
65050
65056
65070
65072
65107
65108
65127
65128
65132
65136
65141
65142
65277
65279
65280
65281
65471
65474
65480
65482
65488
65490
65496
65498
65501
65504
65511
65512
65519
65529
65534
65536
65548
65549
65575
65576
65595
65596
65598
65599
65614
65616
65630
65664
65787
65792
65795
65799
65844
65847
65933
65936
65948
65952
65953
66000
66046
66176
66205
66208
66257
66272
66300
66304
66340
66352
66379
66384
66427
66432
66462
66463
66500
66504
66518
66560
66718
66720
66730
66816
66856
66864
66916
66927
66928
67072
67383
67392
67414
67424
67432
67584
67590
67592
67593
67594
67638
67639
67641
67644
67645
67647
67670
67671
67743
67751
67760
67840
67868
67871
67898
67903
67904
67968
68024
68030
68032
68096
68100
68101
68103
68108
68116
68117
68120
68121
68148
68152
68155
68159
68168
68176
68185
68192
68256
68288
68327
68331
68343
68352
68406
68409
68438
68440
68467
68472
68498
68505
68509
68521
68528
68608
68681
69216
69247
69632
69710
69714
69744
69759
69826
69840
69865
69872
69882
69888
69941
69942
69956
69968
70007
70016
70089
70093
70094
70096
70107
70113
70133
70144
70162
70163
70206
70320
70379
70384
70394
70401
70404
70405
70413
70415
70417
70419
70441
70442
70449
70450
70452
70453
70458
70460
70469
70471
70473
70475
70478
70487
70488
70493
70500
70502
70509
70512
70517
70784
70856
70864
70874
71040
71094
71096
71114
71168
71237
71248
71258
71296
71352
71360
71370
71840
71923
71935
71936
72384
72441
73728
74649
74752
74863
74864
74869
77824
78895
92160
92729
92736
92767
92768
92778
92782
92784
92880
92910
92912
92918
92928
92998
93008
93018
93019
93026
93027
93048
93053
93072
93952
94021
94032
94079
94095
94112
110592
110594
113664
113771
113776
113789
113792
113801
113808
113818
113820
113828
118784
119030
119040
119079
119081
119262
119296
119366
119552
119639
119648
119666
119808
119893
119894
119965
119966
119968
119970
119971
119973
119975
119977
119981
119982
119994
119995
119996
119997
120004
120005
120070
120071
120075
120077
120085
120086
120093
120094
120122
120123
120127
120128
120133
120134
120135
120138
120145
120146
120486
120488
120780
120782
120832
124928
125125
125127
125143
126464
126468
126469
126496
126497
126499
126500
126501
126503
126504
126505
126515
126516
126520
126521
126522
126523
126524
126530
126531
126535
126536
126537
126538
126539
126540
126541
126544
126545
126547
126548
126549
126551
126552
126553
126554
126555
126556
126557
126558
126559
126560
126561
126563
126564
126565
126567
126571
126572
126579
126580
126584
126585
126589
126590
126591
126592
126602
126603
126620
126625
126628
126629
126634
126635
126652
126704
126706
126976
127020
127024
127124
127136
127151
127153
127168
127169
127184
127185
127222
127232
127245
127248
127279
127280
127340
127344
127387
127462
127491
127504
127547
127552
127561
127568
127570
127744
127789
127792
127870
127872
127951
127956
127992
128000
128255
128256
128331
128336
128378
128379
128420
128421
128579
128581
128720
128736
128749
128752
128756
128768
128884
128896
128981
129024
129036
129040
129096
129104
129114
129120
129160
129168
129198
131072
173783
173824
177973
177984
178206
194560
195102
917505
917506
917536
917632
917760
918000
983040
1048574
1048576
1114110
END
| 6.073311 | 77 | 0.816357 |
edb51f59cef7b4a7e46d3510a2b4023725539136 | 1,836 | pm | Perl | auto-lib/Paws/CognitoIdentity/CognitoIdentityProvider.pm | galenhuntington/aws-sdk-perl | 13b775dcb5f0b3764f0a82f3679ed5c7721e67d3 | [
"Apache-2.0"
] | null | null | null | auto-lib/Paws/CognitoIdentity/CognitoIdentityProvider.pm | galenhuntington/aws-sdk-perl | 13b775dcb5f0b3764f0a82f3679ed5c7721e67d3 | [
"Apache-2.0"
] | null | null | null | auto-lib/Paws/CognitoIdentity/CognitoIdentityProvider.pm | galenhuntington/aws-sdk-perl | 13b775dcb5f0b3764f0a82f3679ed5c7721e67d3 | [
"Apache-2.0"
] | null | null | null | package Paws::CognitoIdentity::CognitoIdentityProvider;
use Moose;
has ClientId => (is => 'ro', isa => 'Str');
has ProviderName => (is => 'ro', isa => 'Str');
has ServerSideTokenCheck => (is => 'ro', isa => 'Bool');
1;
### main pod documentation begin ###
=head1 NAME
Paws::CognitoIdentity::CognitoIdentityProvider
=head1 USAGE
This class represents one of two things:
=head3 Arguments in a call to a service
Use the attributes of this class as arguments to methods. You shouldn't make instances of this class.
Each attribute should be used as a named argument in the calls that expect this type of object.
As an example, if Att1 is expected to be a Paws::CognitoIdentity::CognitoIdentityProvider object:
$service_obj->Method(Att1 => { ClientId => $value, ..., ServerSideTokenCheck => $value });
=head3 Results returned from an API call
Use accessors for each attribute. If Att1 is expected to be an Paws::CognitoIdentity::CognitoIdentityProvider object:
$result = $service_obj->Method(...);
$result->Att1->ClientId
=head1 DESCRIPTION
A provider representing an Amazon Cognito Identity User Pool and its
client ID.
=head1 ATTRIBUTES
=head2 ClientId => Str
The client ID for the Amazon Cognito Identity User Pool.
=head2 ProviderName => Str
The provider name for an Amazon Cognito Identity User Pool. For
example, C<cognito-idp.us-east-1.amazonaws.com/us-east-1_123456789>.
=head2 ServerSideTokenCheck => Bool
TRUE if server-side token validation is enabled for the identity
providerE<rsquo>s token.
=head1 SEE ALSO
This class forms part of L<Paws>, describing an object used in L<Paws::CognitoIdentity>
=head1 BUGS and CONTRIBUTIONS
The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
=cut
| 25.5 | 117 | 0.742375 |
ed85904c65e70f9cb7f78d5aa11232c5e5aaa095 | 1,991 | pm | Perl | auto-lib/Paws/RedShift/SnapshotCopyGrant.pm | agimenez/aws-sdk-perl | 9c4dff7d1af2ff0210c28ca44fb9e92bc625712b | [
"Apache-2.0"
] | null | null | null | auto-lib/Paws/RedShift/SnapshotCopyGrant.pm | agimenez/aws-sdk-perl | 9c4dff7d1af2ff0210c28ca44fb9e92bc625712b | [
"Apache-2.0"
] | null | null | null | auto-lib/Paws/RedShift/SnapshotCopyGrant.pm | agimenez/aws-sdk-perl | 9c4dff7d1af2ff0210c28ca44fb9e92bc625712b | [
"Apache-2.0"
] | null | null | null | package Paws::RedShift::SnapshotCopyGrant;
use Moose;
has KmsKeyId => (is => 'ro', isa => 'Str');
has SnapshotCopyGrantName => (is => 'ro', isa => 'Str');
has Tags => (is => 'ro', isa => 'ArrayRef[Paws::RedShift::Tag]', request_name => 'Tag', traits => ['NameInRequest']);
1;
### main pod documentation begin ###
=head1 NAME
Paws::RedShift::SnapshotCopyGrant
=head1 USAGE
This class represents one of two things:
=head3 Arguments in a call to a service
Use the attributes of this class as arguments to methods. You shouldn't make instances of this class.
Each attribute should be used as a named argument in the calls that expect this type of object.
As an example, if Att1 is expected to be a Paws::RedShift::SnapshotCopyGrant object:
$service_obj->Method(Att1 => { KmsKeyId => $value, ..., Tags => $value });
=head3 Results returned from an API call
Use accessors for each attribute. If Att1 is expected to be an Paws::RedShift::SnapshotCopyGrant object:
$result = $service_obj->Method(...);
$result->Att1->KmsKeyId
=head1 DESCRIPTION
The snapshot copy grant that grants Amazon Redshift permission to
encrypt copied snapshots with the specified customer master key (CMK)
from AWS KMS in the destination region.
For more information about managing snapshot copy grants, go to Amazon
Redshift Database Encryption in the I<Amazon Redshift Cluster
Management Guide>.
=head1 ATTRIBUTES
=head2 KmsKeyId => Str
The unique identifier of the customer master key (CMK) in AWS KMS to
which Amazon Redshift is granted permission.
=head2 SnapshotCopyGrantName => Str
The name of the snapshot copy grant.
=head2 Tags => ArrayRef[L<Paws::RedShift::Tag>]
A list of tag instances.
=head1 SEE ALSO
This class forms part of L<Paws>, describing an object used in L<Paws::RedShift>
=head1 BUGS and CONTRIBUTIONS
The source code is located here: https://github.com/pplu/aws-sdk-perl
Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
=cut
| 26.197368 | 119 | 0.736313 |
ed606508d323390abbefbf6b38337889d787c630 | 563 | t | Perl | t/08context.t | DavidEGx/p5-json-path | 56c05efe145d14b87c677229ff765b6f47915637 | [
"X11",
"Unlicense",
"MIT"
] | 3 | 2017-07-20T14:25:20.000Z | 2020-12-16T00:36:50.000Z | t/08context.t | DavidEGx/p5-json-path | 56c05efe145d14b87c677229ff765b6f47915637 | [
"X11",
"Unlicense",
"MIT"
] | 10 | 2018-04-02T21:35:33.000Z | 2022-03-15T15:56:40.000Z | t/08context.t | DavidEGx/p5-json-path | 56c05efe145d14b87c677229ff765b6f47915637 | [
"X11",
"Unlicense",
"MIT"
] | 7 | 2017-10-24T18:23:27.000Z | 2022-01-31T17:49:01.000Z | use Test::More;
use JSON::Path;
use JSON;
my $object = from_json(<<'JSON');
{
"elements": [
{ "id": 1 },
{ "id": 2 }
],
"empty": null
}
JSON
my $path1 = JSON::Path->new('$.elements[*]');
my @arr = $path1->values($object);
is_deeply \@arr, [ { id => 1 }, { id => 2 } ], 'multiple values in list context';
my $scal = $path1->values($object);
cmp_ok $scal, '==', 2, 'multiple values in scalar context';
my $path2 = JSON::Path->new('$.empty');
ok !!$path2->values($object), 'boolean check for existing null is true';
done_testing();
| 22.52 | 81 | 0.568384 |
edb8bf31aded1ea678a154f40ac17ca95c968b3a | 1,333 | pm | Perl | auto-lib/Azure/BatchData/AddJob.pm | pplu/azure-sdk-perl | 26cbef2d926f571bc1617c26338c106856f95568 | [
"Apache-2.0"
] | null | null | null | auto-lib/Azure/BatchData/AddJob.pm | pplu/azure-sdk-perl | 26cbef2d926f571bc1617c26338c106856f95568 | [
"Apache-2.0"
] | null | null | null | auto-lib/Azure/BatchData/AddJob.pm | pplu/azure-sdk-perl | 26cbef2d926f571bc1617c26338c106856f95568 | [
"Apache-2.0"
] | 1 | 2021-04-08T15:26:39.000Z | 2021-04-08T15:26:39.000Z | package Azure::BatchData::AddJob;
use Moose;
use MooseX::ClassAttribute;
has 'api_version' => (is => 'ro', required => 1, isa => 'Str', default => '2018-08-01.7.0',
traits => [ 'Azure::ParamInQuery', 'Azure::LocationInResponse' ], location => 'api-version',
);
has 'client_request_id' => (is => 'ro', isa => 'Str',
traits => [ 'Azure::ParamInHeader', 'Azure::LocationInResponse' ], location => 'client-request-id',
);
has 'job' => (is => 'ro', required => 1, isa => 'Azure::BatchData::JobAddParameter',
traits => [ 'Azure::ParamInBody' ],
);
has 'ocp_date' => (is => 'ro', isa => 'Str',
traits => [ 'Azure::ParamInHeader', 'Azure::LocationInResponse' ], location => 'ocp-date',
);
has 'return_client_request_id' => (is => 'ro', isa => 'Bool',
traits => [ 'Azure::ParamInHeader', 'Azure::LocationInResponse' ], location => 'return-client-request-id',
);
has 'timeout' => (is => 'ro', isa => 'Int',
traits => [ 'Azure::ParamInQuery' ],
);
class_has _api_uri => (is => 'ro', default => '/jobs');
class_has _returns => (is => 'ro', isa => 'HashRef', default => sub { {
201 => undef,
default => 'Azure::BatchData::AddJobResult',
} });
class_has _is_async => (is => 'ro', default => 0);
class_has _api_method => (is => 'ro', default => 'POST');
1;
| 38.085714 | 110 | 0.573893 |
ed6f40965238686b36809c293eade185d477e56e | 3,773 | pm | Perl | modules/Bio/EnsEMBL/Production/Pipeline/Webdatafile/lib/IndexWig.pm | ens-bwalts/ensembl-production | ce2ccecbf5d2a56528e3f77e9a4e930a3d0129db | [
"Apache-2.0"
] | 9 | 2016-06-24T16:58:52.000Z | 2021-01-27T15:38:00.000Z | modules/Bio/EnsEMBL/Production/Pipeline/Webdatafile/lib/IndexWig.pm | ens-bwalts/ensembl-production | ce2ccecbf5d2a56528e3f77e9a4e930a3d0129db | [
"Apache-2.0"
] | 187 | 2015-01-09T10:27:54.000Z | 2022-03-08T11:28:24.000Z | modules/Bio/EnsEMBL/Production/Pipeline/Webdatafile/lib/IndexWig.pm | ens-bwalts/ensembl-production | ce2ccecbf5d2a56528e3f77e9a4e930a3d0129db | [
"Apache-2.0"
] | 60 | 2015-01-22T16:08:35.000Z | 2022-03-04T17:31:32.000Z | =head1 LICENSE
Copyright [1999-2015] Wellcome Trust Sanger Institute and the EMBL-European Bioinformatics Institute
Copyright [2016-2020] EMBL-European Bioinformatics Institute
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=cut
package Bio::EnsEMBL::Production::Pipeline::Webdatafile::lib::IndexWig;
use Moose;
has 'clip' => ( isa => 'Bool', is => 'ro', required => 1, default => 1 );
has 'all_chrs' => ( isa => 'Bool', is => 'ro', required => 1, default => 1 );
has 'fixed_summaries' => ( isa => 'Bool', is => 'ro', required => 1, default => 1 );
has 'strip_track_lines' => ( isa => 'Bool', is => 'ro', required => 1, default => 1 );
has 'genome' => ( isa => 'Any', is => 'rw', required => 1 );
sub index_gzip_wig {
my ($self, $wig_path, $target_path) = @_;
confess "Cannot find the path ${wig_path}" unless $wig_path->is_file();
my $remove_temp_files = $self->remove_temp_files();
my $strip_track_lines = $self->strip_track_lines();
my $genome = $self->genome();
my $genome_id = $genome->genome_id();
if(! defined $target_path) {
$target_path = $wig_path->sibling($wig_path->basename('.wig.gz'));
}
my $target_fh = $target_path->openw();
my $raw_path = $wig_path->stringify();
open my $fh, '-|', 'gzip -dc '.$raw_path or confess "Cannot open $raw_path for reading through gzip: $!";
while(my $line = <$fh>) {
if($strip_track_lines && $line =~ /^track type=.+/) {
next;
}
print $target_fh $line or confess "Cannot print to file concat filehandle: $!";
}
close $fh or confess "Cannot close input wig file: $!";
close $target_fh or confess "Cannot close target wig file: $!";
my $bigwig = $self->to_bigwig($target_path);
$target_path->remove() if $remove_temp_files;
return $bigwig;
}
sub index {
my ($self, $wig_path, $indexed_path) = @_;
confess "Cannot find $wig_path" unless $wig_path->exists();
confess "$wig_path is not a file" unless $wig_path->is_file();
return $self->to_bigwig($wig_path, $indexed_path);
}
sub to_bigwig {
my ($self, $wig_path, $indexed_path) = @_;
if(! defined $indexed_path) {
my $indexed_name = $wig_path->basename('.wig').'.bw';
$indexed_path = $wig_path->sibling($indexed_name);
}
my $cmd = 'wigToBigWig';
my @args;
push(@args, '-clip') if $self->clip();
push(@args, '-keepAllChromosomes') if $self->all_chrs();
push(@args, '-fixedSummaries') if $self->fixed_summaries();
push(@args, $wig_path->stringify(), $self->chrom_sizes(), $indexed_path->stringify());
$self->system($cmd, @args);
return $indexed_path;
}
sub bigwig_cat {
my ($self, $bigwig_paths, $target_path) = @_;
confess 'No target path given' if ! defined $target_path;
my $cmd = 'bigWigCat';
my @args = ($target_path->stringify(), map { $_->stringify() } @{$bigwig_paths});
$self->system($cmd, @args);
return $target_path;
}
sub chrom_sizes {
my ($self) = @_;
return $self->genome()->chrom_sizes_path()->stringify();
}
sub system {
my ($self, $cmd, @args) = @_;
my ($stdout, $stderr, $exit) = capture {
system($cmd, @args);
};
if($exit != 0) {
print STDERR $stdout;
print STDERR $stderr;
confess "Return code was ${exit}. Failed to execute command $cmd: $!";
}
return;
}
1;
| 33.990991 | 107 | 0.64776 |
edc0dd2962a592e1e119583071d61daad980906f | 11,022 | pm | Perl | test/ssl-tests/protocol_version.pm | rosecurity/https-github.com-openssl-openssl | 4483fbae10a9277812cc8a587ef58a5a512fe7c9 | [
"OpenSSL"
] | 5 | 2019-07-14T08:16:17.000Z | 2020-05-01T16:32:17.000Z | test/ssl-tests/protocol_version.pm | rosecurity/https-github.com-openssl-openssl | 4483fbae10a9277812cc8a587ef58a5a512fe7c9 | [
"OpenSSL"
] | null | null | null | test/ssl-tests/protocol_version.pm | rosecurity/https-github.com-openssl-openssl | 4483fbae10a9277812cc8a587ef58a5a512fe7c9 | [
"OpenSSL"
] | 4 | 2019-01-13T13:35:31.000Z | 2022-01-11T02:01:20.000Z | # -*- mode: perl; -*-
# Copyright 2016-2016 The OpenSSL Project Authors. All Rights Reserved.
#
# Licensed under the OpenSSL license (the "License"). You may not use
# this file except in compliance with the License. You can obtain a copy
# in the file LICENSE in the source distribution or at
# https://www.openssl.org/source/license.html
## Test version negotiation
package ssltests;
use strict;
use warnings;
use List::Util qw/max min/;
use OpenSSL::Test;
use OpenSSL::Test::Utils qw/anydisabled alldisabled disabled/;
setup("no_test_here");
my @tls_protocols = ("SSLv3", "TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3");
# undef stands for "no limit".
my @min_tls_protocols = (undef, "SSLv3", "TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3");
my @max_tls_protocols = ("SSLv3", "TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3", undef);
my @is_tls_disabled = anydisabled("ssl3", "tls1", "tls1_1", "tls1_2", "tls1_3");
my $min_tls_enabled; my $max_tls_enabled;
# Protocol configuration works in cascades, i.e.,
# $no_tls1_1 disables TLSv1.1 and below.
#
# $min_enabled and $max_enabled will be correct if there is at least one
# protocol enabled.
foreach my $i (0..$#tls_protocols) {
if (!$is_tls_disabled[$i]) {
$min_tls_enabled = $i;
last;
}
}
foreach my $i (0..$#tls_protocols) {
if (!$is_tls_disabled[$i]) {
$max_tls_enabled = $i;
}
}
my @dtls_protocols = ("DTLSv1", "DTLSv1.2");
# undef stands for "no limit".
my @min_dtls_protocols = (undef, "DTLSv1", "DTLSv1.2");
my @max_dtls_protocols = ("DTLSv1", "DTLSv1.2", undef);
my @is_dtls_disabled = anydisabled("dtls1", "dtls1_2");
my $min_dtls_enabled; my $max_dtls_enabled;
# $min_enabled and $max_enabled will be correct if there is at least one
# protocol enabled.
foreach my $i (0..$#dtls_protocols) {
if (!$is_dtls_disabled[$i]) {
$min_dtls_enabled = $i;
last;
}
}
foreach my $i (0..$#dtls_protocols) {
if (!$is_dtls_disabled[$i]) {
$max_dtls_enabled = $i;
}
}
sub no_tests {
my ($dtls) = @_;
return $dtls ? alldisabled("dtls1", "dtls1_2") :
alldisabled("ssl3", "tls1", "tls1_1", "tls1_2", "tls1_3");
}
sub generate_version_tests {
my ($method) = @_;
my $dtls = $method eq "DTLS";
# Don't write the redundant "Method = TLS" into the configuration.
undef $method if !$dtls;
my @protocols = $dtls ? @dtls_protocols : @tls_protocols;
my @min_protocols = $dtls ? @min_dtls_protocols : @min_tls_protocols;
my @max_protocols = $dtls ? @max_dtls_protocols : @max_tls_protocols;
my $min_enabled = $dtls ? $min_dtls_enabled : $min_tls_enabled;
my $max_enabled = $dtls ? $max_dtls_enabled : $max_tls_enabled;
if (no_tests($dtls)) {
return;
}
my @tests = ();
for (my $sctp = 0; $sctp < ($dtls && !disabled("sctp") ? 2 : 1); $sctp++) {
foreach my $c_min (0..$#min_protocols) {
my $c_max_min = $c_min == 0 ? 0 : $c_min - 1;
foreach my $c_max ($c_max_min..$#max_protocols) {
foreach my $s_min (0..$#min_protocols) {
my $s_max_min = $s_min == 0 ? 0 : $s_min - 1;
foreach my $s_max ($s_max_min..$#max_protocols) {
my ($result, $protocol) =
expected_result($c_min, $c_max, $s_min, $s_max,
$min_enabled, $max_enabled,
\@protocols);
push @tests, {
"name" => "version-negotiation",
"client" => {
"MinProtocol" => $min_protocols[$c_min],
"MaxProtocol" => $max_protocols[$c_max],
},
"server" => {
"MinProtocol" => $min_protocols[$s_min],
"MaxProtocol" => $max_protocols[$s_max],
},
"test" => {
"ExpectedResult" => $result,
"ExpectedProtocol" => $protocol,
"Method" => $method,
}
};
$tests[-1]{"test"}{"UseSCTP"} = "Yes" if $sctp;
}
}
}
}
}
return @tests if disabled("tls1_3") || disabled("tls1_2") || $dtls;
#Add some version/ciphersuite sanity check tests
push @tests, {
"name" => "ciphersuite-sanity-check-client",
"client" => {
#Offering only <=TLSv1.2 ciphersuites with TLSv1.3 should fail
"CipherString" => "AES128-SHA",
},
"server" => {
"MaxProtocol" => "TLSv1.2"
},
"test" => {
"ExpectedResult" => "ClientFail",
}
};
push @tests, {
"name" => "ciphersuite-sanity-check-server",
"client" => {
"CipherString" => "AES128-SHA",
"MaxProtocol" => "TLSv1.2"
},
"server" => {
#Allowing only <=TLSv1.2 ciphersuites with TLSv1.3 should fail
"CipherString" => "AES128-SHA",
},
"test" => {
"ExpectedResult" => "ServerFail",
}
};
return @tests;
}
sub generate_resumption_tests {
my ($method) = @_;
my $dtls = $method eq "DTLS";
# Don't write the redundant "Method = TLS" into the configuration.
undef $method if !$dtls;
my @protocols = $dtls ? @dtls_protocols : @tls_protocols;
my $min_enabled = $dtls ? $min_dtls_enabled : $min_tls_enabled;
my $max_enabled = $dtls ? $max_dtls_enabled : $max_tls_enabled;
if (no_tests($dtls)) {
return;
}
my @server_tests = ();
my @client_tests = ();
# Obtain the first session against a fixed-version server/client.
foreach my $original_protocol($min_enabled..$max_enabled) {
# Upgrade or downgrade the server/client max version support and test
# that it upgrades, downgrades or resumes the session as well.
foreach my $resume_protocol($min_enabled..$max_enabled) {
my $resumption_expected;
# We should only resume on exact version match.
if ($original_protocol eq $resume_protocol) {
$resumption_expected = "Yes";
} else {
$resumption_expected = "No";
}
for (my $sctp = 0; $sctp < ($dtls && !disabled("sctp") ? 2 : 1);
$sctp++) {
foreach my $ticket ("SessionTicket", "-SessionTicket") {
# Client is flexible, server upgrades/downgrades.
push @server_tests, {
"name" => "resumption",
"client" => { },
"server" => {
"MinProtocol" => $protocols[$original_protocol],
"MaxProtocol" => $protocols[$original_protocol],
"Options" => $ticket,
},
"resume_server" => {
"MaxProtocol" => $protocols[$resume_protocol],
},
"test" => {
"ExpectedProtocol" => $protocols[$resume_protocol],
"Method" => $method,
"HandshakeMode" => "Resume",
"ResumptionExpected" => $resumption_expected,
}
};
$server_tests[-1]{"test"}{"UseSCTP"} = "Yes" if $sctp;
# Server is flexible, client upgrades/downgrades.
push @client_tests, {
"name" => "resumption",
"client" => {
"MinProtocol" => $protocols[$original_protocol],
"MaxProtocol" => $protocols[$original_protocol],
},
"server" => {
"Options" => $ticket,
},
"resume_client" => {
"MaxProtocol" => $protocols[$resume_protocol],
},
"test" => {
"ExpectedProtocol" => $protocols[$resume_protocol],
"Method" => $method,
"HandshakeMode" => "Resume",
"ResumptionExpected" => $resumption_expected,
}
};
$client_tests[-1]{"test"}{"UseSCTP"} = "Yes" if $sctp;
}
}
}
}
if (!disabled("tls1_3") && !$dtls) {
push @client_tests, {
"name" => "resumption-with-hrr",
"client" => {
},
"server" => {
"Curves" => "P-256"
},
"resume_client" => {
},
"test" => {
"ExpectedProtocol" => "TLSv1.3",
"Method" => "TLS",
"HandshakeMode" => "Resume",
"ResumptionExpected" => "Yes",
}
};
}
return (@server_tests, @client_tests);
}
sub expected_result {
my ($c_min, $c_max, $s_min, $s_max, $min_enabled, $max_enabled,
$protocols) = @_;
# Adjust for "undef" (no limit).
$c_min = $c_min == 0 ? 0 : $c_min - 1;
$c_max = $c_max == scalar @$protocols ? $c_max - 1 : $c_max;
$s_min = $s_min == 0 ? 0 : $s_min - 1;
$s_max = $s_max == scalar @$protocols ? $s_max - 1 : $s_max;
# We now have at least one protocol enabled, so $min_enabled and
# $max_enabled are well-defined.
$c_min = max $c_min, $min_enabled;
$s_min = max $s_min, $min_enabled;
$c_max = min $c_max, $max_enabled;
$s_max = min $s_max, $max_enabled;
if ($c_min > $c_max) {
# Client should fail to even send a hello.
return ("ClientFail", undef);
} elsif ($s_min > $s_max) {
# Server has no protocols, should always fail.
return ("ServerFail", undef);
} elsif ($s_min > $c_max) {
# Server doesn't support the client range.
return ("ServerFail", undef);
} elsif ($c_min > $s_max) {
my @prots = @$protocols;
if ($prots[$c_max] eq "TLSv1.3") {
# Client will have sent supported_versions, so server will know
# that there are no overlapping versions.
return ("ServerFail", undef);
} else {
# Server will try with a version that is lower than the lowest
# supported client version.
return ("ClientFail", undef);
}
} else {
# Server and client ranges overlap.
my $max_common = $s_max < $c_max ? $s_max : $c_max;
return ("Success", $protocols->[$max_common]);
}
}
1;
| 35.214058 | 83 | 0.492833 |
ed9d2fca236e570da18bb4c32026b5128e22e3c0 | 1,473 | pm | Perl | lib/Bio/EnsEMBL/DataCheck/Checks/UnreviewedXrefs.pm | gnaamati/ensembl-datacheck | b5eb55a4caa8dc0a7d03322fa6eabe95b7081701 | [
"Apache-2.0"
] | 5 | 2018-06-13T10:40:06.000Z | 2021-01-27T15:37:46.000Z | lib/Bio/EnsEMBL/DataCheck/Checks/UnreviewedXrefs.pm | gnaamati/ensembl-datacheck | b5eb55a4caa8dc0a7d03322fa6eabe95b7081701 | [
"Apache-2.0"
] | 388 | 2018-06-15T15:56:12.000Z | 2022-03-29T07:52:46.000Z | lib/Bio/EnsEMBL/DataCheck/Checks/UnreviewedXrefs.pm | gnaamati/ensembl-datacheck | b5eb55a4caa8dc0a7d03322fa6eabe95b7081701 | [
"Apache-2.0"
] | 33 | 2018-06-15T11:14:29.000Z | 2022-03-04T11:45:27.000Z | =head1 LICENSE
Copyright [2018-2020] EMBL-European Bioinformatics Institute
Licensed under the Apache License, Version 2.0 (the 'License');
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an 'AS IS' BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=cut
package Bio::EnsEMBL::DataCheck::Checks::UnreviewedXrefs;
use warnings;
use strict;
use Moose;
use Test::More;
use Bio::EnsEMBL::DataCheck::Test::DataCheck;
extends 'Bio::EnsEMBL::DataCheck::DbCheck';
use constant {
NAME => 'UnreviewedXrefs',
DESCRIPTION => 'Uniprot xrefs do not have Unreviewed as their primary DB accession',
GROUPS => ['core', 'xref', 'xref_mapping'],
DB_TYPES => ['core'],
TABLES => ['xref','external_db'],
PER_DB => 1
};
sub tests {
my ($self) = @_;
my $desc = "Uniprot xrefs do not have Unreviewed as their primary DB accession";
my $sql = qq/
SELECT COUNT(*) FROM
xref x, external_db e
WHERE
e.external_db_id=x.external_db_id AND
e.db_name LIKE 'UniProt%' AND
x.dbprimary_acc='Unreviewed'
/;
is_rows_zero($self->dba, $sql, $desc);
}
1;
| 27.792453 | 89 | 0.697217 |
edba500e103cfc62b9dca9c89094f33baed806da | 25,465 | pl | Perl | Aula 7/swipl/library/check.pl | FunkyCracky/good_owly_stuff | c56c1897d85724982da531d04ed6b310c0464098 | [
"MIT"
] | null | null | null | Aula 7/swipl/library/check.pl | FunkyCracky/good_owly_stuff | c56c1897d85724982da531d04ed6b310c0464098 | [
"MIT"
] | null | null | null | Aula 7/swipl/library/check.pl | FunkyCracky/good_owly_stuff | c56c1897d85724982da531d04ed6b310c0464098 | [
"MIT"
] | 1 | 2021-05-09T15:32:17.000Z | 2021-05-09T15:32:17.000Z | /* Part of SWI-Prolog
Author: Jan Wielemaker
E-mail: [email protected]
WWW: http://www.swi-prolog.org
Copyright (c) 1985-2018, University of Amsterdam
VU University Amsterdam
CWI, Amsterdam
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
:- module(check,
[ check/0, % run all checks
list_undefined/0, % list undefined predicates
list_undefined/1, % +Options
list_autoload/0, % list predicates that need autoloading
list_redefined/0, % list redefinitions
list_void_declarations/0, % list declarations with no clauses
list_trivial_fails/0, % list goals that trivially fail
list_trivial_fails/1, % +Options
list_strings/0, % list string objects in clauses
list_strings/1 % +Options
]).
:- use_module(library(lists)).
:- use_module(library(pairs)).
:- use_module(library(option)).
:- use_module(library(apply)).
:- use_module(library(prolog_codewalk)).
:- use_module(library(occurs)).
:- set_prolog_flag(generate_debug_info, false).
:- multifile
trivial_fail_goal/1,
string_predicate/1,
valid_string_goal/1,
checker/2.
:- dynamic checker/2.
/** <module> Consistency checking
This library provides some consistency checks for the loaded Prolog
program. The predicate make/0 runs list_undefined/0 to find undefined
predicates in `user' modules.
@see gxref/0 provides a graphical cross referencer
@see PceEmacs performs real time consistency checks while you edit
@see library(prolog_xref) implements `offline' cross-referencing
@see library(prolog_codewalk) implements `online' analysis
*/
:- predicate_options(list_undefined/1, 1,
[ module_class(list(oneof([user,library])))
]).
%! check is det.
%
% Run all consistency checks defined by checker/2. Checks enabled by
% default are:
%
% * list_undefined/0 reports undefined predicates
% * list_trivial_fails/0 reports calls for which there is no
% matching clause.
% * list_redefined/0 reports predicates that have a local
% definition and a global definition. Note that these are
% *not* errors.
% * list_autoload/0 lists predicates that will be defined at
% runtime using the autoloader.
check :-
checker(Checker, Message),
print_message(informational,check(pass(Message))),
catch(Checker,E,print_message(error,E)),
fail.
check.
%! list_undefined is det.
%! list_undefined(+Options) is det.
%
% Report undefined predicates. This predicate finds undefined
% predicates by decompiling and analyzing the body of all clauses.
% Options:
%
% * module_class(+Classes)
% Process modules of the given Classes. The default for
% classes is =|[user]|=. For example, to include the
% libraries into the examination, use =|[user,library]|=.
%
% @see gxref/0 provides a graphical cross-referencer.
% @see make/0 calls list_undefined/0
:- thread_local
undef/2.
list_undefined :-
list_undefined([]).
list_undefined(Options) :-
merge_options(Options,
[ module_class([user])
],
WalkOptions),
call_cleanup(
prolog_walk_code([ undefined(trace),
on_trace(found_undef)
| WalkOptions
]),
collect_undef(Grouped)),
( Grouped == []
-> true
; print_message(warning, check(undefined_procedures, Grouped))
).
% The following predicates are used from library(prolog_autoload).
:- public
found_undef/3,
collect_undef/1.
collect_undef(Grouped) :-
findall(PI-From, retract(undef(PI, From)), Pairs),
keysort(Pairs, Sorted),
group_pairs_by_key(Sorted, Grouped).
found_undef(To, _Caller, From) :-
goal_pi(To, PI),
( undef(PI, From)
-> true
; compiled(PI)
-> true
; assertz(undef(PI,From))
).
compiled(system:'$call_cleanup'/0). % compiled to VM instructions
compiled(system:'$catch'/0).
compiled(system:'$cut'/0).
compiled(system:'$reset'/0).
compiled(system:'$call_continuation'/1).
compiled(system:'$shift'/1).
compiled('$engines':'$yield'/0).
goal_pi(M:Head, M:Name/Arity) :-
functor(Head, Name, Arity).
%! list_autoload is det.
%
% Report predicates that may be auto-loaded. These are predicates
% that are not defined, but will be loaded on demand if
% referenced.
%
% @tbd This predicate uses an older mechanism for finding
% undefined predicates. Should be synchronized with
% list undefined.
% @see autoload/0
list_autoload :-
setup_call_cleanup(
( current_prolog_flag(access_level, OldLevel),
current_prolog_flag(autoload, OldAutoLoad),
set_prolog_flag(access_level, system),
set_prolog_flag(autoload, false)
),
list_autoload_(OldLevel),
( set_prolog_flag(access_level, OldLevel),
set_prolog_flag(autoload, OldAutoLoad)
)).
list_autoload_(SystemMode) :-
( setof(Lib-Pred,
autoload_predicate(Module, Lib, Pred, SystemMode),
Pairs),
print_message(informational,
check(autoload(Module, Pairs))),
fail
; true
).
autoload_predicate(Module, Library, Name/Arity, SystemMode) :-
predicate_property(Module:Head, undefined),
check_module_enabled(Module, SystemMode),
( \+ predicate_property(Module:Head, imported_from(_)),
functor(Head, Name, Arity),
'$find_library'(Module, Name, Arity, _LoadModule, Library),
referenced(Module:Head, Module, _)
-> true
).
check_module_enabled(_, system) :- !.
check_module_enabled(Module, _) :-
\+ import_module(Module, system).
%! referenced(+Predicate, ?Module, -ClauseRef) is nondet.
%
% True if clause ClauseRef references Predicate.
referenced(Term, Module, Ref) :-
Goal = Module:_Head,
current_predicate(_, Goal),
'$get_predicate_attribute'(Goal, system, 0),
\+ '$get_predicate_attribute'(Goal, imported, _),
nth_clause(Goal, _, Ref),
'$xr_member'(Ref, Term).
%! list_redefined
%
% Lists predicates that are defined in the global module =user= as
% well as in a normal module; that is, predicates for which the
% local definition overrules the global default definition.
list_redefined :-
setup_call_cleanup(
( current_prolog_flag(access_level, OldLevel),
set_prolog_flag(access_level, system)
),
list_redefined_,
set_prolog_flag(access_level, OldLevel)).
list_redefined_ :-
current_module(Module),
Module \== system,
current_predicate(_, Module:Head),
\+ predicate_property(Module:Head, imported_from(_)),
( global_module(Super),
Super \== Module,
'$c_current_predicate'(_, Super:Head),
\+ redefined_ok(Head),
'$syspreds':'$defined_predicate'(Super:Head),
\+ predicate_property(Super:Head, (dynamic)),
\+ predicate_property(Super:Head, imported_from(Module)),
functor(Head, Name, Arity)
-> print_message(informational,
check(redefined(Module, Super, Name/Arity)))
),
fail.
list_redefined_.
redefined_ok('$mode'(_,_)).
redefined_ok('$pldoc'(_,_,_,_)).
redefined_ok('$pred_option'(_,_,_,_)).
global_module(user).
global_module(system).
%! list_void_declarations is det.
%
% List predicates that have declared attributes, but no clauses.
list_void_declarations :-
P = _:_,
( predicate_property(P, undefined),
( '$get_predicate_attribute'(P, meta_predicate, Pattern),
print_message(warning,
check(void_declaration(P, meta_predicate(Pattern))))
; void_attribute(Attr),
'$get_predicate_attribute'(P, Attr, 1),
print_message(warning,
check(void_declaration(P, Attr)))
),
fail
; true
).
void_attribute(public).
void_attribute(volatile).
%! list_trivial_fails is det.
%! list_trivial_fails(+Options) is det.
%
% List goals that trivially fail because there is no matching
% clause. Options:
%
% * module_class(+Classes)
% Process modules of the given Classes. The default for
% classes is =|[user]|=. For example, to include the
% libraries into the examination, use =|[user,library]|=.
:- thread_local
trivial_fail/2.
list_trivial_fails :-
list_trivial_fails([]).
list_trivial_fails(Options) :-
merge_options(Options,
[ module_class([user]),
infer_meta_predicates(false),
autoload(false),
evaluate(false),
trace_reference(_),
on_trace(check_trivial_fail)
],
WalkOptions),
prolog_walk_code([ source(false)
| WalkOptions
]),
findall(CRef, retract(trivial_fail(clause(CRef), _)), Clauses),
( Clauses == []
-> true
; print_message(warning, check(trivial_failures)),
prolog_walk_code([ clauses(Clauses)
| WalkOptions
]),
findall(Goal-From, retract(trivial_fail(From, Goal)), Pairs),
keysort(Pairs, Sorted),
group_pairs_by_key(Sorted, Grouped),
maplist(report_trivial_fail, Grouped)
).
%! trivial_fail_goal(:Goal)
%
% Multifile hook that tells list_trivial_fails/0 to accept Goal as
% valid.
trivial_fail_goal(pce_expansion:pce_class(_, _, template, _, _, _)).
trivial_fail_goal(pce_host:property(system_source_prefix(_))).
:- public
check_trivial_fail/3.
check_trivial_fail(MGoal0, _Caller, From) :-
( MGoal0 = M:Goal,
atom(M),
callable(Goal),
predicate_property(MGoal0, interpreted),
\+ predicate_property(MGoal0, dynamic),
\+ predicate_property(MGoal0, multifile),
\+ trivial_fail_goal(MGoal0)
-> ( predicate_property(MGoal0, meta_predicate(Meta))
-> qualify_meta_goal(MGoal0, Meta, MGoal)
; MGoal = MGoal0
),
( clause(MGoal, _)
-> true
; assertz(trivial_fail(From, MGoal))
)
; true
).
report_trivial_fail(Goal-FromList) :-
print_message(warning, check(trivial_failure(Goal, FromList))).
%! qualify_meta_goal(+Module, +MetaSpec, +Goal, -QualifiedGoal)
%
% Qualify a goal if the goal calls a meta predicate
qualify_meta_goal(M:Goal0, Meta, M:Goal) :-
functor(Goal0, F, N),
functor(Goal, F, N),
qualify_meta_goal(1, M, Meta, Goal0, Goal).
qualify_meta_goal(N, M, Meta, Goal0, Goal) :-
arg(N, Meta, ArgM),
!,
arg(N, Goal0, Arg0),
arg(N, Goal, Arg),
N1 is N + 1,
( module_qualified(ArgM)
-> add_module(Arg0, M, Arg)
; Arg = Arg0
),
meta_goal(N1, Meta, Goal0, Goal).
meta_goal(_, _, _, _).
add_module(Arg, M, M:Arg) :-
var(Arg),
!.
add_module(M:Arg, _, MArg) :-
!,
add_module(Arg, M, MArg).
add_module(Arg, M, M:Arg).
module_qualified(N) :- integer(N), !.
module_qualified(:).
module_qualified(^).
%! list_strings is det.
%! list_strings(+Options) is det.
%
% List strings that appear in clauses. This predicate is used to
% find portability issues for changing the Prolog flag
% =double_quotes= from =codes= to =string=, creating packed string
% objects. Warnings may be suppressed using the following
% multifile hooks:
%
% - string_predicate/1 to stop checking certain predicates
% - valid_string_goal/1 to tell the checker that a goal is
% safe.
%
% @see Prolog flag =double_quotes=.
list_strings :-
list_strings([module_class([user])]).
list_strings(Options) :-
( prolog_program_clause(ClauseRef, Options),
clause(Head, Body, ClauseRef),
\+ ( predicate_indicator(Head, PI),
string_predicate(PI)
),
make_clause(Head, Body, Clause),
findall(T,
( sub_term(T, Head),
string(T)
; Head = M:_,
goal_in_body(Goal, M, Body),
( valid_string_goal(Goal)
-> fail
; sub_term(T, Goal),
string(T)
)
), Ts0),
sort(Ts0, Ts),
member(T, Ts),
message_context(ClauseRef, T, Clause, Context),
print_message(warning,
check(string_in_clause(T, Context))),
fail
; true
).
make_clause(Head, true, Head) :- !.
make_clause(Head, Body, (Head:-Body)).
%! goal_in_body(-G, +M, +Body) is nondet.
%
% True when G is a goal called from Body.
goal_in_body(M:G, M, G) :-
var(G),
!.
goal_in_body(G, _, M:G0) :-
atom(M),
!,
goal_in_body(G, M, G0).
goal_in_body(G, M, Control) :-
nonvar(Control),
control(Control, Subs),
!,
member(Sub, Subs),
goal_in_body(G, M, Sub).
goal_in_body(G, M, G0) :-
callable(G0),
( atom(M)
-> TM = M
; TM = system
),
predicate_property(TM:G0, meta_predicate(Spec)),
!,
( strip_goals(G0, Spec, G1),
simple_goal_in_body(G, M, G1)
; arg(I, Spec, Meta),
arg(I, G0, G1),
extend(Meta, G1, G2),
goal_in_body(G, M, G2)
).
goal_in_body(G, M, G0) :-
simple_goal_in_body(G, M, G0).
simple_goal_in_body(G, M, G0) :-
( atom(M),
callable(G0),
predicate_property(M:G0, imported_from(M2))
-> G = M2:G0
; G = M:G0
).
control((A,B), [A,B]).
control((A;B), [A,B]).
control((A->B), [A,B]).
control((A*->B), [A,B]).
control((\+A), [A]).
strip_goals(G0, Spec, G) :-
functor(G0, Name, Arity),
functor(G, Name, Arity),
strip_goal_args(1, G0, Spec, G).
strip_goal_args(I, G0, Spec, G) :-
arg(I, G0, A0),
!,
arg(I, Spec, M),
( extend(M, A0, _)
-> arg(I, G, '<meta-goal>')
; arg(I, G, A0)
),
I2 is I + 1,
strip_goal_args(I2, G0, Spec, G).
strip_goal_args(_, _, _, _).
extend(I, G0, G) :-
callable(G0),
integer(I), I>0,
!,
length(L, I),
extend_list(G0, L, G).
extend(0, G, G).
extend(^, G, G).
extend_list(M:G0, L, M:G) :-
!,
callable(G0),
extend_list(G0, L, G).
extend_list(G0, L, G) :-
G0 =.. List,
append(List, L, All),
G =.. All.
message_context(ClauseRef, String, Clause, file_term_position(File, StringPos)) :-
clause_info(ClauseRef, File, TermPos, _Vars),
prolog_codewalk:subterm_pos(String, Clause, ==, TermPos, StringPos),
!.
message_context(ClauseRef, _String, _Clause, file(File, Line, -1, _)) :-
clause_property(ClauseRef, file(File)),
clause_property(ClauseRef, line_count(Line)),
!.
message_context(ClauseRef, _String, _Clause, clause(ClauseRef)).
:- meta_predicate
predicate_indicator(:, -).
predicate_indicator(Module:Head, Module:Name/Arity) :-
functor(Head, Name, Arity).
predicate_indicator(Module:Head, Module:Name//DCGArity) :-
functor(Head, Name, Arity),
DCGArity is Arity-2.
%! string_predicate(:PredicateIndicator)
%
% Multifile hook to disable list_strings/0 on the given predicate.
% This is typically used for facts that store strings.
string_predicate(_:'$pldoc'/4).
string_predicate(pce_principal:send_implementation/3).
string_predicate(pce_principal:pce_lazy_get_method/3).
string_predicate(pce_principal:pce_lazy_send_method/3).
string_predicate(pce_principal:pce_class/6).
string_predicate(prolog_xref:pred_comment/4).
string_predicate(prolog_xref:module_comment/3).
string_predicate(pldoc_process:structured_comment//2).
string_predicate(pldoc_process:structured_command_start/3).
string_predicate(pldoc_process:separator_line//0).
string_predicate(pldoc_register:mydoc/3).
string_predicate(http_header:separators/1).
%! valid_string_goal(+Goal) is semidet.
%
% Multifile hook that qualifies Goal as valid for list_strings/0.
% For example, format("Hello world~n") is considered proper use of
% string constants.
% system predicates
valid_string_goal(system:format(S)) :- string(S).
valid_string_goal(system:format(S,_)) :- string(S).
valid_string_goal(system:format(_,S,_)) :- string(S).
valid_string_goal(system:string_codes(S,_)) :- string(S).
valid_string_goal(system:string_code(_,S,_)) :- string(S).
valid_string_goal(system:throw(msg(S,_))) :- string(S).
valid_string_goal('$dcg':phrase(S,_,_)) :- string(S).
valid_string_goal('$dcg':phrase(S,_)) :- string(S).
valid_string_goal(system: is(_,_)). % arithmetic allows for "x"
valid_string_goal(system: =:=(_,_)).
valid_string_goal(system: >(_,_)).
valid_string_goal(system: <(_,_)).
valid_string_goal(system: >=(_,_)).
valid_string_goal(system: =<(_,_)).
% library stuff
valid_string_goal(dcg_basics:string_without(S,_,_,_)) :- string(S).
valid_string_goal(git:read_url(S,_,_)) :- string(S).
valid_string_goal(tipc:tipc_subscribe(_,_,_,_,S)) :- string(S).
valid_string_goal(charsio:format_to_chars(Format,_,_)) :- string(Format).
valid_string_goal(charsio:format_to_chars(Format,_,_,_)) :- string(Format).
valid_string_goal(codesio:format_to_codes(Format,_,_)) :- string(Format).
valid_string_goal(codesio:format_to_codes(Format,_,_,_)) :- string(Format).
/*******************************
* EXTENSION HOOKS *
*******************************/
%! checker(:Goal, +Message:text)
%
% Register code validation routines. Each clause defines a Goal
% which performs a consistency check executed by check/0. Message
% is a short description of the check. For example, assuming the
% `my_checks` module defines a predicate list_format_mistakes/0:
%
% ==
% :- multifile check:checker/2.
% check:checker(my_checks:list_format_mistakes,
% "errors with format/2 arguments").
% ==
%
% The predicate is dynamic, so you can disable checks with retract/1.
% For example, to stop reporting redefined predicates:
%
% ==
% retract(check:checker(list_redefined,_)).
% ==
checker(list_undefined, 'undefined predicates').
checker(list_trivial_fails, 'trivial failures').
checker(list_redefined, 'redefined system and global predicates').
checker(list_void_declarations, 'predicates with declarations but without clauses').
checker(list_autoload, 'predicates that need autoloading').
/*******************************
* MESSAGES *
*******************************/
:- multifile
prolog:message/3.
prolog:message(check(pass(Comment))) -->
[ 'Checking ~w ...'-[Comment] ].
prolog:message(check(find_references(Preds))) -->
{ length(Preds, N)
},
[ 'Scanning for references to ~D possibly undefined predicates'-[N] ].
prolog:message(check(undefined_procedures, Grouped)) -->
[ 'The predicates below are not defined. If these are defined', nl,
'at runtime using assert/1, use :- dynamic Name/Arity.', nl, nl
],
undefined_procedures(Grouped).
prolog:message(check(undefined_unreferenced_predicates)) -->
[ 'The predicates below are not defined, and are not', nl,
'referenced.', nl, nl
].
prolog:message(check(undefined_unreferenced(Pred))) -->
predicate(Pred).
prolog:message(check(autoload(Module, Pairs))) -->
{ module_property(Module, file(Path))
},
!,
[ 'Into module ~w ('-[Module] ],
short_filename(Path),
[ ')', nl ],
autoload(Pairs).
prolog:message(check(autoload(Module, Pairs))) -->
[ 'Into module ~w'-[Module], nl ],
autoload(Pairs).
prolog:message(check(redefined(In, From, Pred))) -->
predicate(In:Pred),
redefined(In, From).
prolog:message(check(trivial_failures)) -->
[ 'The following goals fail because there are no matching clauses.' ].
prolog:message(check(trivial_failure(Goal, Refs))) -->
{ map_list_to_pairs(sort_reference_key, Refs, Keyed),
keysort(Keyed, KeySorted),
pairs_values(KeySorted, SortedRefs)
},
goal(Goal),
[ ', which is called from'-[], nl ],
referenced_by(SortedRefs).
prolog:message(check(string_in_clause(String, Context))) -->
prolog:message_location(Context),
[ 'String ~q'-[String] ].
prolog:message(check(void_declaration(P, Decl))) -->
predicate(P),
[ ' is declared as ~p, but has no clauses'-[Decl] ].
undefined_procedures([]) -->
[].
undefined_procedures([H|T]) -->
undefined_procedure(H),
undefined_procedures(T).
undefined_procedure(Pred-Refs) -->
{ map_list_to_pairs(sort_reference_key, Refs, Keyed),
keysort(Keyed, KeySorted),
pairs_values(KeySorted, SortedRefs)
},
predicate(Pred),
[ ', which is referenced by', nl ],
referenced_by(SortedRefs).
redefined(user, system) -->
[ '~t~30| System predicate redefined globally' ].
redefined(_, system) -->
[ '~t~30| Redefined system predicate' ].
redefined(_, user) -->
[ '~t~30| Redefined global predicate' ].
goal(user:Goal) -->
!,
[ '~p'-[Goal] ].
goal(Goal) -->
!,
[ '~p'-[Goal] ].
predicate(Module:Name/Arity) -->
{ atom(Module),
atom(Name),
integer(Arity),
functor(Head, Name, Arity),
predicate_name(Module:Head, PName)
},
!,
[ '~w'-[PName] ].
predicate(Module:Head) -->
{ atom(Module),
callable(Head),
predicate_name(Module:Head, PName)
},
!,
[ '~w'-[PName] ].
predicate(Name/Arity) -->
{ atom(Name),
integer(Arity)
},
!,
predicate(user:Name/Arity).
autoload([]) -->
[].
autoload([Lib-Pred|T]) -->
[ ' ' ],
predicate(Pred),
[ '~t~24| from ' ],
short_filename(Lib),
[ nl ],
autoload(T).
%! sort_reference_key(+Reference, -Key) is det.
%
% Create a stable key for sorting references to predicates.
sort_reference_key(Term, key(M:Name/Arity, N, ClausePos)) :-
clause_ref(Term, ClauseRef, ClausePos),
!,
nth_clause(Pred, N, ClauseRef),
strip_module(Pred, M, Head),
functor(Head, Name, Arity).
sort_reference_key(Term, Term).
clause_ref(clause_term_position(ClauseRef, TermPos), ClauseRef, ClausePos) :-
arg(1, TermPos, ClausePos).
clause_ref(clause(ClauseRef), ClauseRef, 0).
referenced_by([]) -->
[].
referenced_by([Ref|T]) -->
['\t'], prolog:message_location(Ref),
predicate_indicator(Ref),
[ nl ],
referenced_by(T).
predicate_indicator(clause_term_position(ClauseRef, _)) -->
{ nonvar(ClauseRef) },
!,
predicate_indicator(clause(ClauseRef)).
predicate_indicator(clause(ClauseRef)) -->
{ clause_name(ClauseRef, Name) },
[ '~w'-[Name] ].
predicate_indicator(file_term_position(_,_)) -->
[ '(initialization)' ].
predicate_indicator(file(_,_,_,_)) -->
[ '(initialization)' ].
short_filename(Path) -->
{ short_filename(Path, Spec)
},
[ '~q'-[Spec] ].
short_filename(Path, Spec) :-
absolute_file_name('', Here),
atom_concat(Here, Local0, Path),
!,
remove_leading_slash(Local0, Spec).
short_filename(Path, Spec) :-
findall(LenAlias, aliased_path(Path, LenAlias), Keyed),
keysort(Keyed, [_-Spec|_]).
short_filename(Path, Path).
aliased_path(Path, Len-Spec) :-
setof(Alias, Spec^(user:file_search_path(Alias, Spec)), Aliases),
member(Alias, Aliases),
Term =.. [Alias, '.'],
absolute_file_name(Term,
[ file_type(directory),
file_errors(fail),
solutions(all)
], Prefix),
atom_concat(Prefix, Local0, Path),
remove_leading_slash(Local0, Local),
atom_length(Local, Len),
Spec =.. [Alias, Local].
remove_leading_slash(Path, Local) :-
atom_concat(/, Local, Path),
!.
remove_leading_slash(Path, Path).
| 30.829298 | 84 | 0.628785 |
ed097f799510a8ee476a111afdf3d719f5c2868e | 2,329 | pl | Perl | kb/7_loan_agreement_with_that.pl | LegalMachineLab/LogicalEnglish | 0ca70763962a0cc9bc8994adb79a271e70fab8e5 | [
"Apache-2.0"
] | 7 | 2022-01-16T15:28:25.000Z | 2022-03-05T13:51:04.000Z | kb/7_loan_agreement_with_that.pl | LegalMachineLab/LogicalEnglish | 0ca70763962a0cc9bc8994adb79a271e70fab8e5 | [
"Apache-2.0"
] | 2 | 2021-12-12T02:33:49.000Z | 2022-01-26T19:50:37.000Z | kb/7_loan_agreement_with_that.pl | LegalMachineLab/LogicalEnglish | 0ca70763962a0cc9bc8994adb79a271e70fab8e5 | [
"Apache-2.0"
] | 2 | 2022-02-08T12:11:56.000Z | 2022-02-17T00:07:28.000Z | :- module('loanwiththat+http://tests.com',[]).
en("the target language is: prolog.
the templates are:
*an obligation* is that *a description*,
*a lender* notifies *a borrower* on *a date* that *a message*,
*a person* has *an obligation*,
*a borrower* cures on *a date* the failure of *an obligation*,
*a borrower* fails on *a date* to fulfil *an obligation*,
*a borrower* pays *an amount* to *a lender* on *a date*,
*a borrower* defaults on *a date*,
the loan is accelerated on *a date*,
*a date* is on or before *a later date*.
the knowledge base obligation includes:
the borrower has obligation1.
obligation1 is that the borrower pays 550 to the lender on 2015-06-01.
the borrower has obligation2.
obligation2 is that the borrower pays 525 to the lender on 2016-06-01.
% the borrower defaults on a date D3
the loan is accelerated on a date D3
if the borrower has an obligation
and the borrower fails on a date D0 to fulfil the obligation
and the lender notifies the borrower on a date D1 that the borrower fails on D0 to fulfil the obligation
and D3 is 2 days after D1
and it is not the case that
the borrower cures on a date D2 the failure of the obligation
and D2 is on or before D3.
the borrower fails on a date to fulfil an obligation
if the obligation is that the borrower pays an amount to the lender on the date
and it is not the case that
the borrower pays the amount to the lender on the date.
the borrower cures on a first date the failure of an obligation
if the obligation is that the borrower pays an amount to the lender on a second date
and the borrower pays the amount to the lender on the first date.
A date D1 is on or before a date D2
if D2 is a X days after D1
and X >= 0.
scenario one is:
the lender notifies the borrower on 2016-06-02 that the borrower fails on 2016-06-01 to fulfil obligation2.
the borrower pays 525 to the lender on 2016-06-02.
query one is:
which person defaults on which day.
query two is:
which first person notifies which second person on which date that which message.
query three is:
the loan is accelerated on which date.
").
/** <examples>
?- answer("query one with scenario one").
?- answer("query two with scenario one").
?- answer("query three with scenario one").
*/ | 35.830769 | 109 | 0.722198 |
edcb96eae500de5787c48a08c9d42c9984337a8e | 2,536 | pm | Perl | misc-scripts/xref_mapping/XrefParser/WormbaseDatabaseStableIDParser.pm | msmanoj/ensembl | f357e3331a6b529fa82a08d0cee0be8ea1d90887 | [
"Apache-2.0"
] | null | null | null | misc-scripts/xref_mapping/XrefParser/WormbaseDatabaseStableIDParser.pm | msmanoj/ensembl | f357e3331a6b529fa82a08d0cee0be8ea1d90887 | [
"Apache-2.0"
] | null | null | null | misc-scripts/xref_mapping/XrefParser/WormbaseDatabaseStableIDParser.pm | msmanoj/ensembl | f357e3331a6b529fa82a08d0cee0be8ea1d90887 | [
"Apache-2.0"
] | null | null | null | =head1 LICENSE
Copyright [1999-2015] Wellcome Trust Sanger Institute and the EMBL-European Bioinformatics Institute
Copyright [2016-2021] EMBL-European Bioinformatics Institute
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=cut
package XrefParser::WormbaseDatabaseStableIDParser;
# Read gene and transcript stable IDs from a WormBase-imported database and create
# xrefs and direct xrefs for them.
# Note the only things that are actually WormBase specific here are the source names
# for the wormbase_gene and wormbase_transcript sources.
use strict;
use warnings;
use Carp;
use base qw( XrefParser::DatabaseParser );
sub run {
my ($self, $ref_arg) = @_;
my $source_id = $ref_arg->{source_id} || confess "Need a source_id";
my $species_id = $ref_arg->{species_id};
my $dsn = $ref_arg->{dsn};
my $verbose = $ref_arg->{verbose};
if((!defined $source_id) or (!defined $species_id) or (!defined $dsn) ){
croak "Need to pass source_id, species_id and dsn as pairs";
}
$verbose |=0;
my $db = $self->connect($dsn); # source db (probably core)
my $xref_db = $self->dbi();
my $xref_sth = $xref_db->prepare( "INSERT INTO xref (accession,label,source_id,species_id) VALUES (?,?,?,?)" );
# read stable IDs
foreach my $type ('gene', 'transcript') {
my $direct_xref_sth = $xref_db->prepare( "INSERT INTO ${type}_direct_xref (general_xref_id,ensembl_stable_id,linkage_xref) VALUES (?,?,?)" );
if($verbose) {
print "Building xrefs from $type stable IDs\n";
}
my $wb_source_id = $self->get_source_id_for_source_name("wormbase_$type");
my $sth = $db->prepare( "SELECT stable_id FROM ${type}" );
$sth->execute();
while(my @row = $sth->fetchrow_array()) {
my $id = $row[0];
# add an xref & a direct xref
$xref_sth->execute($id, $id, $wb_source_id, $species_id);
my $xref_id = $xref_sth->{'mysql_insertid'};
$direct_xref_sth->execute($xref_id, $id, 'Stable ID direct xref');
} # while fetch stable ID
} # foreach type
return 0;
}
1;
| 31.7 | 145 | 0.697555 |
edcde27a73320d5018930ffacd8eed3d05eb5f65 | 4,489 | pl | Perl | external/win_perl/lib/auto/share/dist/DateTime-Locale/dyo-SN.pl | phixion/l0phtcrack | 48ee2f711134e178dbedbd925640f6b3b663fbb5 | [
"Apache-2.0",
"MIT"
] | 2 | 2021-10-20T00:25:39.000Z | 2021-11-08T12:52:42.000Z | external/win_perl/lib/auto/share/dist/DateTime-Locale/dyo-SN.pl | Brute-f0rce/l0phtcrack | 25f681c07828e5e68e0dd788d84cc13c154aed3d | [
"Apache-2.0",
"MIT"
] | null | null | null | external/win_perl/lib/auto/share/dist/DateTime-Locale/dyo-SN.pl | Brute-f0rce/l0phtcrack | 25f681c07828e5e68e0dd788d84cc13c154aed3d | [
"Apache-2.0",
"MIT"
] | 1 | 2022-03-14T06:41:16.000Z | 2022-03-14T06:41:16.000Z | {
am_pm_abbreviated => [
"AM",
"PM",
],
available_formats => {
Bh => "h B",
Bhm => "h:mm B",
Bhms => "h:mm:ss B",
E => "ccc",
EBhm => "E h:mm B",
EBhms => "E h:mm:ss B",
EHm => "E HH:mm",
EHms => "E HH:mm:ss",
Ed => "E d",
Ehm => "E h:mm a",
Ehms => "E h:mm:ss a",
Gy => "G y",
GyMMM => "G y MMM",
GyMMMEd => "G y MMM d, E",
GyMMMd => "G y MMM d",
H => "HH",
Hm => "HH:mm",
Hms => "HH:mm:ss",
Hmsv => "HH:mm:ss v",
Hmv => "HH:mm v",
M => "L",
MEd => "E d/M",
MMM => "LLL",
MMMEd => "E d MMM",
"MMMMW-count-other" => "'week' W 'of' MMMM",
MMMMd => "MMMM d",
MMMd => "d MMM",
Md => "d/M",
d => "d",
h => "h a",
hm => "h:mm a",
hms => "h:mm:ss a",
hmsv => "h:mm:ss a v",
hmv => "h:mm a v",
ms => "m:ss",
y => "y",
yM => "M/y",
yMEd => "E d/M/y",
yMMM => "MMM y",
yMMMEd => "E d MMM y",
yMMMM => "y MMMM",
yMMMd => "d MMM y",
yMd => "d/M/y",
yQQQ => "QQQ y",
yQQQQ => "QQQQ y",
"yw-count-other" => "'week' w 'of' Y",
},
code => "dyo-SN",
date_format_full => "EEEE d MMMM y",
date_format_long => "d MMMM y",
date_format_medium => "d MMM y",
date_format_short => "d/M/y",
datetime_format_full => "{1} {0}",
datetime_format_long => "{1} {0}",
datetime_format_medium => "{1} {0}",
datetime_format_short => "{1} {0}",
day_format_abbreviated => [
"Ten",
"Tal",
"Ala",
"Ara",
"Arj",
"Sib",
"Dim",
],
day_format_narrow => [
"T",
"T",
"A",
"A",
"A",
"S",
"D",
],
day_format_wide => [
"Tene\N{U+014b}",
"Talata",
"Alarbay",
"Aramisay",
"Arjuma",
"Sibiti",
"Dimas",
],
day_stand_alone_abbreviated => [
"Ten",
"Tal",
"Ala",
"Ara",
"Arj",
"Sib",
"Dim",
],
day_stand_alone_narrow => [
"T",
"T",
"A",
"A",
"A",
"S",
"D",
],
day_stand_alone_wide => [
"Tene\N{U+014b}",
"Talata",
"Alarbay",
"Aramisay",
"Arjuma",
"Sibiti",
"Dimas",
],
era_abbreviated => [
"ArY",
"AtY",
],
era_narrow => [
"ArY",
"AtY",
],
era_wide => [
"Ari\N{U+014b}uu Yeesu",
"Atoo\N{U+014b}e Yeesu",
],
first_day_of_week => 1,
glibc_date_1_format => "%a %b %e %H:%M:%S %Z %Y",
glibc_date_format => "%m/%d/%y",
glibc_datetime_format => "%a %b %e %H:%M:%S %Y",
glibc_time_12_format => "%I:%M:%S %p",
glibc_time_format => "%H:%M:%S",
language => "Jola-Fonyi",
month_format_abbreviated => [
"Sa",
"Fe",
"Ma",
"Ab",
"Me",
"Su",
"S\N{U+00fa}",
"Ut",
"Se",
"Ok",
"No",
"De",
],
month_format_narrow => [
"S",
"F",
"M",
"A",
"M",
"S",
"S",
"U",
"S",
"O",
"N",
"D",
],
month_format_wide => [
"Sanvie",
"F\N{U+00e9}birie",
"Mars",
"Aburil",
"Mee",
"Sue\N{U+014b}",
"S\N{U+00fa}uyee",
"Ut",
"Settembar",
"Oktobar",
"Novembar",
"Disambar",
],
month_stand_alone_abbreviated => [
"Sa",
"Fe",
"Ma",
"Ab",
"Me",
"Su",
"S\N{U+00fa}",
"Ut",
"Se",
"Ok",
"No",
"De",
],
month_stand_alone_narrow => [
"S",
"F",
"M",
"A",
"M",
"S",
"S",
"U",
"S",
"O",
"N",
"D",
],
month_stand_alone_wide => [
"Sanvie",
"F\N{U+00e9}birie",
"Mars",
"Aburil",
"Mee",
"Sue\N{U+014b}",
"S\N{U+00fa}uyee",
"Ut",
"Settembar",
"Oktobar",
"Novembar",
"Disambar",
],
name => "Jola-Fonyi Senegal",
native_language => "joola",
native_name => "joola Senegal",
native_script => undef,
native_territory => "Senegal",
native_variant => undef,
quarter_format_abbreviated => [
"Q1",
"Q2",
"Q3",
"Q4",
],
quarter_format_narrow => [
1,
2,
3,
4,
],
quarter_format_wide => [
"Q1",
"Q2",
"Q3",
"Q4",
],
quarter_stand_alone_abbreviated => [
"Q1",
"Q2",
"Q3",
"Q4",
],
quarter_stand_alone_narrow => [
1,
2,
3,
4,
],
quarter_stand_alone_wide => [
"Q1",
"Q2",
"Q3",
"Q4",
],
script => undef,
territory => "Senegal",
time_format_full => "HH:mm:ss zzzz",
time_format_long => "HH:mm:ss z",
time_format_medium => "HH:mm:ss",
time_format_short => "HH:mm",
variant => undef,
version => 32,
}
| 16.564576 | 51 | 0.435063 |
edc84621cb4e76f327af1cb0f44dec0c30f97d57 | 374 | pl | Perl | KOST-Val/src/main/resources_notJar/resources/ExifTool-10.15/Perl/lib/unicore/lib/InIdeogr.pl | rebplu/KOST-VAL | 1537125425068d5faec3bc4f5263df715956ae76 | [
"BSD-3-Clause-No-Nuclear-Warranty"
] | null | null | null | KOST-Val/src/main/resources_notJar/resources/ExifTool-10.15/Perl/lib/unicore/lib/InIdeogr.pl | rebplu/KOST-VAL | 1537125425068d5faec3bc4f5263df715956ae76 | [
"BSD-3-Clause-No-Nuclear-Warranty"
] | null | null | null | KOST-Val/src/main/resources_notJar/resources/ExifTool-10.15/Perl/lib/unicore/lib/InIdeogr.pl | rebplu/KOST-VAL | 1537125425068d5faec3bc4f5263df715956ae76 | [
"BSD-3-Clause-No-Nuclear-Warranty"
] | null | null | null | # !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
# This file is built by ./mktables from e.g. UnicodeData.txt.
# Any changes made here will be lost!
#
# This file supports:
# \p{InIdeographicDescriptionCharacters} (and fuzzy permutations)
#
# Meaning: Block 'Ideographic Description Characters'
#
return <<'END';
2FF0 2FFF Ideographic Description Characters
END
| 26.714286 | 67 | 0.687166 |
ed57ca5a2a5dea3884b4030c10fb47feb53aae06 | 2,079 | pm | Perl | lib/SQL/Functional/MatchClause.pm | frezik/SQL-Functional | 5a5ce04c996b259f98577085938e28ef18f3cc55 | [
"BSD-2-Clause"
] | null | null | null | lib/SQL/Functional/MatchClause.pm | frezik/SQL-Functional | 5a5ce04c996b259f98577085938e28ef18f3cc55 | [
"BSD-2-Clause"
] | 3 | 2016-10-18T12:56:42.000Z | 2017-01-01T14:18:39.000Z | lib/SQL/Functional/MatchClause.pm | frezik/SQL-Functional | 5a5ce04c996b259f98577085938e28ef18f3cc55 | [
"BSD-2-Clause"
] | null | null | null | # Copyright (c) 2016 Timm Murray
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
package SQL::Functional::MatchClause;
use strict;
use warnings;
use Moose;
use namespace::autoclean;
use SQL::Functional::Clause;
with 'SQL::Functional::Clause';
has field => (
is => 'ro',
isa => 'SQL::Functional::FieldClause',
required => 1,
);
has op => (
is => 'ro',
isa => 'Str',
required => 1,
);
has value => (
is => 'ro',
isa => 'SQL::Functional::Clause',
required => 1,
);
sub to_string
{
my ($self) = @_;
return join ' ',
$self->field->to_string,
$self->op,
$self->value->to_string;
}
sub get_params
{
my ($self) = @_;
return $self->value->get_params;
}
no Moose;
__PACKAGE__->meta->make_immutable;
1;
__END__
| 28.094595 | 79 | 0.697932 |
Subsets and Splits