view release on metacpan or search on metacpan
lib/App/SimpleScan/Plugin/Forget.pm view on Meta::CPAN
# 'foo' is now undefined, and '<foo>' will not be replaced
=head1 DESCRIPTION
C<App::SimpleScan::Plugin::Forget> looks through the currently-defined
variables and removes any variables specified as its arguments. If you
try to forget variables that are currently undefined, nothing happens.
=head1 INTERFACE
view release on metacpan or search on metacpan
lib/App/SimpleScan/Plugin/LinkCheck.pm view on Meta::CPAN
use warnings;
use strict;
use Carp;
use Scalar::Util qw(looks_like_number);
use Text::Balanced qw(extract_quotelike extract_multiple);
sub import {
no strict 'refs';
*{caller() . '::_do_has_link'} = \&_do_has_link;
lib/App/SimpleScan/Plugin/LinkCheck.pm view on Meta::CPAN
if (!defined($count)) {
push @code, qq(fail "Missing count";\n);
$test_count++;
$not_bogus = 0;
}
elsif (! looks_like_number($count) ) {
push @code, qq(fail "$count doesn't look like a legal number to me";\n);
$test_count++;
$not_bogus = 0;
}
lib/App/SimpleScan/Plugin/LinkCheck.pm view on Meta::CPAN
You supplied a comparison operator that wasn't one we expected.
=item C<< %s doesn't look like a legal number to me >>
The item you supplied as a count of the number of times you expect to
see the link was not something that looks like a number to Perl.
=back
=head1 CONFIGURATION AND ENVIRONMENT
view release on metacpan or search on metacpan
lib/App/SimpleScan/Plugin/Retry.pm view on Meta::CPAN
our $VERSION = '1.02';
use warnings;
use strict;
use Carp;
use Scalar::Util qw(looks_like_number);
my ($retry);
sub import {
no strict 'refs';
lib/App/SimpleScan/Plugin/Retry.pm view on Meta::CPAN
);
}
sub retry_pragma {
my ($self, $args) = @_;
if (looks_like_number($args)) {
$args = int $args;
$self->stack_code(qq(mech->retry("$args");\n));
}
else {
$self->stack_test(qq(fail "retry count '$args' is not a number";\n));
view release on metacpan or search on metacpan
lib/App/SimulateReads/DB/Handle/Expression.pm view on Meta::CPAN
use App::SimulateReads::Base 'class';
use App::SimulateReads::DB;
use IO::Compress::Gzip 'gzip';
use IO::Uncompress::Gunzip 'gunzip';
use Storable qw/nfreeze thaw/;
use Scalar::Util 'looks_like_number';
with 'App::SimulateReads::Role::IO';
our $VERSION = '0.16'; # VERSION
lib/App/SimulateReads/DB/Handle/Expression.pm view on Meta::CPAN
die "Error parsing expression-matrix '$file': Seqid (first column) not found at line $line\n"
unless defined $fields[0];
die "Error parsing expression-matrix '$file': Count (second column) not found at line $line\n"
unless defined $fields[1];
die "Error parsing expression-matrix '$file': Count (second column) does not look like a number at line $line\n"
if not looks_like_number($fields[1]);
# Only throws a warning, because it is common zero values in expression matrix
if ($fields[1] <= 0) {
log_msg ":: Parsing expression-matrix '$file': Ignoring seqid '$fields[0]': Count (second column) lesser or equal to zero at line $line\n";
next;
view release on metacpan or search on metacpan
lib/App/Slackeria/Output.pm view on Meta::CPAN
App::Slackeria::Output - XHTML output for App::Slackeria
=head1 SYNOPSIS
# $project looks like this:
# {
# perl => {
# Debian => { ok => 1, data => '5.12.3-7' },
# Freshmeat => { ok => 1, data => '5.14.0' },
# },
view release on metacpan or search on metacpan
bin/slaughter view on Meta::CPAN
die "$0 already running - Lock file $lockfile is locked";
#
# The file will be closed when slaughter terminates so although it
# looks like we're leaking a handle here this is intentional.
#
}
=begin doc
view release on metacpan or search on metacpan
lib/App/SlideServer.pm view on Meta::CPAN
use v5.36;
use Mojo::Base 'Mojolicious';
use Mojo::WebSocket 'WS_PING';
use Mojo::File 'path';
use Mojo::DOM;
use Scalar::Util 'looks_like_number';
use File::stat;
use Text::Markdown::Hoedown;
use Carp;
our $VERSION = '0.002'; #VERSION
view release on metacpan or search on metacpan
lib/App/Smbxfer.pm view on Meta::CPAN
=head1 PROGRAM: CONFIGURATION AND ENVIRONMENT
The credentials file that can be used via the '--cred' option should be in the
same format used by smbclient. This file looks as follows:
username = <username>
password = <password>
domain = <domain>
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
which is useful for you as an author of an app. You can use it to
create completion and pod from a spec file.
### Example
For a first overview, here is how an app looks like:
```perl
use strict;
use warnings;
use 5.010;
view release on metacpan or search on metacpan
lib/App/Sqitch.pm view on Meta::CPAN
my (@tried, $prev);
for (my $i = 0; $i <= $#$args; $i++) {
my $arg = $args->[$i] or next;
if ($arg =~ /^-/) {
last if $arg eq '--';
# Skip the next argument if this looks like a pre-0.9999 option.
# There shouldn't be many since we now recommend putting options
# after the command. XXX Remove at some future date.
$i++ if $arg =~ /^(?:-[duhp])|(?:--(?:db-\w+|client|engine|extension|plan-file|registry|top-dir))$/;
next;
}
lib/App/Sqitch.pm view on Meta::CPAN
The name of the Sqitch registry in the target database.
=back
If the C<$target> argument looks like a database URI, it will simply returned
in the hash reference. If the C<$target> argument corresponds to a target
configuration key, the target configuration will be returned, with the C<uri>
value a upgraded to a L<URI> object. Otherwise returns C<undef>.
=head3 C<shell>
view release on metacpan or search on metacpan
listkids|||
list|||
load_module_nocontext|||vn
load_module|5.006000||pv
localize|||
looks_like_bool|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHs|5.011000||p
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
t/10_stouch.t view on Meta::CPAN
my (@il, @tl);
find(sub { push @il, $_ }, File::Spec->catfile(qw(t data ideality t.dir)));
find(sub { push @tl, $_ }, 't.dir');
is_deeply(\@tl, \@il, "Generated directory tree looks ok");
done_testing();
END {
unlink "t.pl" if -e "t.pl";
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
lib/App/SweeperBot.pm view on Meta::CPAN
use 5.006;
our $VERSION = '0.03';
use Scalar::Util qw(looks_like_number);
use Win32::Process qw(NORMAL_PRIORITY_CLASS);
use constant DEBUG => 0;
use constant VERBOSE => 0;
use constant CHEAT => 1;
lib/App/SweeperBot.pm view on Meta::CPAN
# Empty squares are dull.
next SQUARE if ($game_state->[$x][$y] eq 0);
# Unpressed/flag squares don't give us any information.
next SQUARE if (not looks_like_number($game_state->[$x][$y]));
my @adjacent_unpressed = $this->adjacent_unpressed_for($game_state,$x,$y);
# If there are no adjacent unpressed squares, then
# this square is boring.
next SQUARE if not @adjacent_unpressed;
lib/App/SweeperBot.pm view on Meta::CPAN
}
=head2 cheat_is_square_safe
if ($sweeperbot->cheat_is_square_safe($x,$y) {
print "($x,$y) looks safe!\n";
} else {
print "($x,$y) has a mine underneath.\n";
}
If cheats are enabled, returns true if the given square looks
safe to step on, or false if it appears to contain a mine.
Note that especially on fast, multi-core systems, it's possible
for this to move the mouse and capture the required pixel before
minesweeper has had a chance to update it. So if you cheat,
lib/App/SweeperBot.pm view on Meta::CPAN
my $signature = $pixel->Get("signature");
print "Square at @$square has sig of $signature\n" if DEBUG;
if ($signature eq CHEAT_SAFE) {
print "This square (@$square) looks safe\n" if DEBUG;
return 1;
} elsif ($signature eq CHEAT_UNSAFE) {
print "This square (@$square) looks dangerous!\n" if DEBUG;
return;
}
die "Square @$square has unknown cheat-signature\n$signature\n";
}
view release on metacpan or search on metacpan
Change: a54f91503758aa39590951649d35641acc6dd45c
Author: Ronaldo Ferreira de Lima <jimmy.tty@gmail.com>
Date : 2014-09-08 20:33:19 +0000
* Serializer: remove looks_like_number
------------------------------------------
version 0.002 at 2014-05-28 00:34:37 +0000
------------------------------------------
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
lib/App/Tarotplane/Cards.pm view on Meta::CPAN
Returns undef on failure.
=head2 $deck->card($n)
Return $n-th card from deck. The card will be a hash ref that looks like this
{
Term => 'term string',
Definition => 'definition string',
}
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
Generally we expect that plugins will look for variable values having a
particular pattern and ignoring those that don't match. But there is
certainly no reason why you couldn't write a plugin to convert each
variable-value to uppercase, or perform other global operations.
In pseudo-code the processing looks like this:
$data = ( "foo" => "bar",
title => "This is my page title .." );
foreach my $plugin ( $plugins )
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
doc/SchemaExtractor.pm view on Meta::CPAN
## How It Works
### 1. POD Analysis
The extractor looks for parameter documentation in POD:
```perl
=head2 validate_email($email)
=head3 INPUT
view release on metacpan or search on metacpan
lib/App/TestOnTap/Config.pm view on Meta::CPAN
my $configFile = shift;
my $ignoreDeps = shift;
read_config($configFile, my $cfg);
# this looks weird, I know - see https://rt.cpan.org/Public/Bug/Display.html?id=56862
#
# I seem to hit the problem with "Warning: Name "Config::Std::Hash::DEMOLISH" used only once..."
# when running a Par::Packer binary but not when as a 'normal' script.
#
# The below incantation seem to get rid of that, at least for now. Let's see if it reappears...
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
lib/App/ThisDist.pm view on Meta::CPAN
}
}
FROM_ARCHIVE: {
require Filename::Type::Perl::Release;
# if there is a single archive in the directory which looks like a
# perl release, use that.
my @files = grep { -f } glob "*";
my ($distfile, $dist, $ver);
for my $file (@files) {
my $res = Filename::Type::Perl::Release::check_perl_release_filename(filename=>$file);
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";