AnyMQ-Pg

 view release on metacpan or  search on metacpan

inc/Module/Install.pm  view on Meta::CPAN

358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
 
 
 
 
#####################################################################
# Common Utility Functions
 
sub _caller {
        my $depth = 0;
        my $call  = caller($depth);
        while ( $call eq __PACKAGE__ ) {
                $depth++;
                $call = caller($depth);
        }
        return $call;
}
 
# Done in evals to avoid confusing Perl::MinimumVersion
eval( $] >= 5.006 ? <<'END_NEW' : <<'END_OLD' ); die $@ if $@;
sub _read {
        local *FH;
        open( FH, '<', $_[0] ) or die "open($_[0]): $!";
        my $string = do { local $/; <FH> };

inc/Module/Install/Makefile.pm  view on Meta::CPAN

14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
}
 
sub Makefile { $_[0] }
 
my %seen = ();
 
sub prompt {
        shift;
 
        # Infinite loop protection
        my @c = caller();
        if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) {
                die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])";
        }
 
        # In automated testing or non-interactive session, always use defaults
        if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) {
                local $ENV{PERL_MM_USE_DEFAULT} = 1;
                goto &ExtUtils::MakeMaker::prompt;
        } else {
                goto &ExtUtils::MakeMaker::prompt;

inc/Test/Builder.pm  view on Meta::CPAN

764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
sub cmp_ok {
    my( $self, $got, $type, $expect, $name ) = @_;
 
    my $test;
    my $error;
    {
        ## no critic (BuiltinFunctions::ProhibitStringyEval)
 
        local( $@, $!, $SIG{__DIE__} );    # isolate eval
 
        my($pack, $file, $line) = $self->caller();
 
        # This is so that warnings come out at the caller's level
        $test = eval qq[
#line $line "(eval in cmp_ok) $file"
\$got $type \$expect;
];
        $error = $@;
    }
    local $Level = $Level + 1;
    my $ok = $self->ok( $test, $name );

inc/Test/Builder.pm  view on Meta::CPAN

823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
    return $self->diag(<<"DIAGNOSTIC");
    $got
        $type
    $expect
DIAGNOSTIC
}
 
sub _caller_context {
    my $self = shift;
 
    my( $pack, $file, $line ) = $self->caller(1);
 
    my $code = '';
    $code .= "#line $line $file\n" if defined $file and defined $line;
 
    return $code;
}
 
#line 1205
 
sub BAIL_OUT {

inc/Test/Builder.pm  view on Meta::CPAN

1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
sub _message_at_caller {
    my $self = shift;
 
    local $Level = $Level + 1;
    my( $pack, $file, $line ) = $self->caller;
    return join( "", @_ ) . " at $file line $line.\n";
}
 
sub carp {
    my $self = shift;
    return warn $self->_message_at_caller(@_);
}
 
sub croak {
    my $self = shift;
    return die $self->_message_at_caller(@_);
}
 
 
#line 1992
 
sub current_test {
    my( $self, $num ) = @_;
 
    lock( $self->{Curr_Test} );
    if( defined $num ) {

inc/Test/Builder.pm  view on Meta::CPAN

1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
    return $todo if defined $todo;
 
    return '';
}
 
#line 2173
 
sub find_TODO {
    my( $self, $pack, $set, $new_value ) = @_;
 
    $pack = $pack || $self->caller(1) || $self->exported_to;
    return unless $pack;
 
    no strict 'refs';    ## no critic
    my $old_value = ${ $pack . '::TODO' };
    $set and ${ $pack . '::TODO' } = $new_value;
    return $old_value;
}
 
#line 2193

inc/Test/Builder.pm  view on Meta::CPAN

1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
#line 2298
 
sub caller {    ## no critic (Subroutines::ProhibitBuiltinHomonyms)
    my( $self, $height ) = @_;
    $height ||= 0;
 
    my $level = $self->level + $height + 1;
    my @caller;
    do {
        @caller = CORE::caller( $level );
        $level--;
    } until @caller;
    return wantarray ? @caller : $caller[0];
}
 
#line 2315
 
#line 2329
 
#'#

inc/Test/More.pm  view on Meta::CPAN

7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#---- perlcritic exemptions. ----#
 
# We use a lot of subroutine prototypes
## no critic (Subroutines::ProhibitSubroutinePrototypes)
 
# Can't use Carp because it might cause use_ok() to accidentally succeed
# even though the module being used forgot to use Carp.  Yes, this
# actually happened.
sub _carp {
    my( $file, $line ) = ( caller(1) )[ 1, 2 ];
    return warn @_, " at $file line $line\n";
}
 
our $VERSION = '0.98';
$VERSION = eval $VERSION;    ## no critic (BuiltinFunctions::ProhibitStringyEval)
 
our @ISA    = qw(Test::Builder::Module);
our @EXPORT = qw(ok use_ok require_ok
  is isnt like unlike is_deeply

inc/parent.pm  view on Meta::CPAN

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#line 1
package parent;
use strict;
use vars qw($VERSION);
$VERSION = '0.223';
 
sub import {
    my $class = shift;
 
    my $inheritor = caller(0);
 
    if ( @_ and $_[0] eq '-norequire' ) {
        shift @_;
    } else {
        for ( my @filename = @_ ) {
            if ( $_ eq $inheritor ) {
                warn "Class '$inheritor' tried to inherit from itself\n";
            };
 
            s{::|'}{/}g;



( run in 0.263 second using v1.01-cache-2.11-cpan-55f5a4728d2 )