looks results from the CPAN

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 all matches for this distribution

App-StaticImageGallery

1 match

		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 all matches for this distribution

App-Stouch

1 match

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 all matches for this distribution

App-Stow-Check

1 match

		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 all matches for this distribution

App-SweeperBot

1 match


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;


			# 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;

}

=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,

	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 all matches for this distribution

App-Table2YAML

1 match

CHANGES view on Meta::CPAN


  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 all matches for this distribution

App-TailRabbit-Growl

1 match

		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 all matches for this distribution

App-TailRabbit

1 match

		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 all matches for this distribution

App-Tarotplane

1 match

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 all matches for this distribution

App-Tel

12 results

		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 all matches for this distribution

App-Templer

3 results

PLUGINS.md view on Meta::CPAN

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 all matches for this distribution

App-Test-DWG-LibreDWG-DwgRead

1 match

		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 all matches for this distribution

App-Test-DWG-LibreDWG-JSON

1 match

		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 all matches for this distribution

App-TestOnTap

1 match

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 all matches for this distribution

App-ThinPacker

1 match

		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 all matches for this distribution

App-ThisDist

1 match

lib/App/ThisDist.pm view on Meta::CPAN

            }
        }

      FROM_ARCHIVE: {
            require Filename::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::Perl::Release::check_perl_release_filename(filename=>$file);

view all matches for this distribution

App-Tickit-Hello

1 match

		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 all matches for this distribution

App-TimeTracker

1 match

bin/tracker view on Meta::CPAN

hierarchy consisting of the current year and the current month. This
makes it easy (easier..) to find a specific C<tracking file> in case
you need to make some manual corrections (an interface for easier
editing of C<tracking files> is planned).

The filename of a C<tracking file> looks like
'YYYYMMDD-HHMMSS_$project.trc', for example:
F<20110811-090437_App_TimeTracker.trc>.

=head1 CONFIGURATION

view all matches for this distribution

App-TimelogTxt

1 match

lib/App/TimelogTxt/Tutorial.pod view on Meta::CPAN

you want some form of summarized information. The other reporting commands take
care of that.

=head3 Detail Report

The report I use the most looks like the following:

   $ timelog report yesterday

This report shows the data for the given date grouped by project. Although the
actual times are missing and the data is re-ordered, you can get a really good

view all matches for this distribution

App-Todo

1 match

		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 all matches for this distribution

App-Toodledo

1 match

lib/App/Toodledo.pm view on Meta::CPAN

will be called with the object as the first argument and
any C<@args> as the rest.

=head2 $todo->readable( $object, $attribute )

Currently just looks to see if the given C<$attribute> of C<$object>
is a date and if so, returns the C<preferred_date_formst> string
from L<App::Toodledo::Util> instead of the stored epoch second count.
If the date is null, returns an empty string (rather than the Toodledo
display of "no date").

view all matches for this distribution

App-Toolforge-MixNMatch

1 match

		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 all matches for this distribution

App-Translit-String

1 match

		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 all matches for this distribution

App-Unicode-Block

1 match

		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 all matches for this distribution

App-Unix-RPasswd

1 match

		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 all matches for this distribution

App-Video-Generator

1 match

		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 all matches for this distribution

App-VirtualBoxUtils

1 match

lib/App/VirtualBoxUtils.pm view on Meta::CPAN

};

our $default_filter = sub {
    my $p = shift;

    do { $p->{_note} = "fname looks like VirtualBox"; goto FOUND } if $p->{fname} =~ /\A(VirtualBoxVM|VirtualBox|VBoxSVC)\z/;
    goto NOT_FOUND;
  FOUND:
    log_trace "Found VirtualBox process (PID=%d, cmdline=%s, note=%s)", $p->{pid}, $p->{cmndline}, $p->{_note};
    return 1;
  NOT_FOUND:

view all matches for this distribution

App-WRT

2 results

lib/App/WRT/Markup.pm view on Meta::CPAN

Inline replace <textile> markup in a string.

=cut

# This is exactly the kind of code that, even though it isn't doing anything
# especially over the top, looks ghastly to people who don't read Perl, so I'll
# try to explain a bit.

sub textile_process {

  # First, there's a state variable here which can retain the Text::Textile

view all matches for this distribution

App-Whatsit

1 match