view release on metacpan or  search on metacpan

lib/Acme/IRC/Art.pm  view on Meta::CPAN

=cut

sub result {
 my ($this) = shift;
 use Data::Dumper;
 return map {join '',@{$_}} @{$this->{canevas}};
}


=head1 Methodes

 view release on metacpan or  search on metacpan

t/01_spec.t  view on Meta::CPAN

use Test::More;

use Acme::JWT;
use Crypt::OpenSSL::RSA;
use Data::Dumper;

sub is_d {
    my ($got, $expected, $test_name) = @_;
    local $Data::Dumper::Terse = 1;
    is(Data::Dumper->Dump([$got]), Data::Dumper->Dump([$expected]), $test_name);
}

my $payload = {foo => 'bar'};

{

 view release on metacpan or  search on metacpan

lib/Acme/JavaTrace.pm  view on Meta::CPAN

# 
# _use_data_dumper()
# ----------------
sub _use_data_dumper {
    require Data::Dumper;
    import Data::Dumper;
    $Data::Dumper::Indent = 1;      # no fancy indent
    $Data::Dumper::Terse  = 1;      # don't use $VAR unless needed
    $Data::Dumper::Sortkeys = 1;    # sort keys
    #$Data::Dumper::Deparse = 1;     # deparse code refs
    {
        local $^W = 0; 
        *Devel::SimpleTrace::_use_data_dumper = sub {};
    }
}

 view release on metacpan or  search on metacpan

lib/Acme/KeyboardMarathon.pm  view on Meta::CPAN

package Acme::KeyboardMarathon;
$Acme::KeyboardMarathon::VERSION = '1.27';

use Carp;
use Data::Dumper;
use Math::BigInt;

use integer;
use warnings;
use strict;

 view release on metacpan or  search on metacpan

eg/kiyoshi.pl  view on Meta::CPAN

#!/usr/bin/env perl

use utf8;
use strict;
use warnings;
use Data::Dumper;
use Acme::Kiyoshi::Array;

my @ary = ();

push @ary, "ズン";

 view release on metacpan or  search on metacpan

example/dump.pl  view on Meta::CPAN

#!perl -w
use strict;
use Acme::Lambda::Expr qw(:all);
use Data::Dumper;

my $f = abs($x - $y) ** 2;

print $f->deparse, "\n";

my $dx = Data::Dumper->new([$f], ['f']);
print $dx->Sortkeys(1)->Quotekeys(0)->Dump();

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

Errors from configure prereqs:
EOW
        . do {
            require Data::Dumper; Data::Dumper->new([ \%errors ])->Indent(2)->Terse(1)->Sortkeys(1)->Dump;
        };

        sleep 10 if -t STDIN && (-t STDOUT || !(-f STDOUT || -c STDOUT));
    }

 view release on metacpan or  search on metacpan

Makefile.PL  view on Meta::CPAN

use strict;
use warnings;
use ExtUtils::MakeMaker;
use ExtUtils::Liblist;
use Data::Dumper;
use Config;
use Try::Tiny;

# See lib/ExtUtils/MakeMaker.pm for details of how to influence
# the contents of the Makefile that is written.

 view release on metacpan or  search on metacpan

lib/Acme/Magic8Ball.pm  view on Meta::CPAN

$VERSION    = "1.3"; 
$CONSISTENT = 0;
@ISA        = qw(Exporter);
@EXPORT_OK  = qw(ask);

use Data::Dumper;

sub import {
    $CONSISTENT = grep { /^:consistent$/ } @_;
    @_ = grep { !/^:consistent$/ } @_;
    goto &Exporter::import;

 view release on metacpan or  search on metacpan

lib/Acme/Mitey/Cards/Mite.pm  view on Meta::CPAN

# Exportable error handlers
sub _error_handler {
    my ( $func, $message, @args ) = @_;
    if ( @args ) {
        require Data::Dumper;
        local $Data::Dumper::Terse  = 1;
        local $Data::Dumper::Indent = 0;
        $message = sprintf $message, map {
            ref($_) ? Data::Dumper::Dumper($_) : defined($_) ? $_ : '(undef)'
        } @args;
    }
    my $next = do { require Carp; \&{"Carp::$func"} };
    @_ = ( $message );
    goto $next;

 view release on metacpan or  search on metacpan

lib/Acme/Monkey.pm  view on Meta::CPAN

    }
}

sub dump {
    my $self = shift;
    use Data::Dumper;
    print Dumper($self);
    return;
}

=head2 see

 view release on metacpan or  search on metacpan

inc/Spiffy.pm  view on Meta::CPAN

    *{"${package}::$field"} = $sub;
    return $code if defined wantarray;
}

sub default_as_code {
    require Data::Dumper;
    local $Data::Dumper::Sortkeys = 1;
    my $code = Data::Dumper::Dumper(shift);
    $code =~ s/^\$VAR1 = //;
    $code =~ s/;$//;
    return $code;
}

 view release on metacpan or  search on metacpan

lib/Acme/PSON.pm  view on Meta::CPAN

use strict;
use warnings;
use vars qw( @EXPORT_OK );
use Carp;
use Data::Dumper;
use Exporter::Lite;
@EXPORT_OK = qw(obj2pson pson2obj);

use Readonly;
Readonly my $VARNAME => 'PSON_VALUE';

sub obj2pson {
    my $obj = shift;

    local $Data::Dumper::Indent  = 0;
    local $Data::Dumper::Varname = $VARNAME;
    return Dumper($obj);
}

sub pson2obj {
    my $str = shift;

 view release on metacpan or  search on metacpan

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

# XXX Remove this when things are stable.
sub error {
    my ($class, $error) = @_;
    if (-e 'inc' and not -e 'inc/.author') {
        require Data::Dumper;
        $Data::Dumper::Sortkeys = 1;
        my $dump1 = Data::Dumper::Dumper(\%INC);
        my $dump2 = Data::Dumper::Dumper(\@INC);
        die <<"...";
This should not have happened. Hopefully this dump will explain the problem:

inc::Module::Package: $inc::Module::Package::VERSION
Module::Package: $Module::Package::VERSION

 view release on metacpan or  search on metacpan

lib/Acme/Perl/VM.pm  view on Meta::CPAN

    my($cv) = @_;
    return $cv->XSUB || $external{ ${$cv} };
}

sub ddx{
    require Data::Dumper;
    my $ddx = Data::Dumper->new(@_);
    $ddx->Indent(1);
    $ddx->Terse(TRUE);
    $ddx->Quotekeys(FALSE);
    $ddx->Useqq(TRUE);
    return $ddx if defined wantarray;

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

Errors from configure prereqs:
EOW
        . do {
            require Data::Dumper; Data::Dumper->new([ \%errors ])->Indent(2)->Terse(1)->Sortkeys(1)->Dump;
        };

        sleep 10 if -t STDIN && (-t STDOUT || !(-f STDOUT || -c STDOUT));
    }

 view release on metacpan or  search on metacpan

lib/Acme/PlayCode/Plugin/NumberPlus.pm  view on Meta::CPAN

    my ( $token_flag ) = @_;
    
    my @tokens = $self->tokens;
    my $token  = $tokens[$token_flag];
    
    use Data::Dumper;
#    print STDERR Dumper(\$token);
    
    my $orginal_flag = $token_flag;
    if ( $token->isa('PPI::Token::Operator') ) {
        my $op = $token->content;

 view release on metacpan or  search on metacpan

lib/Acme/Pointer.pm  view on Meta::CPAN

    use strict;
    use warnings;
    use utf8;
    use feature qw/say/;
    use Data::Dumper;
    use Acme::Pointer;

    my $a = {
        a => 20,
        b => [1,2]

 view release on metacpan or  search on metacpan

lib/Acme/PriPara/MainMembers.pm  view on Meta::CPAN

package Acme::PriPara::MainMembers;
use Mouse;

use Data::Section::Simple;
use YAML::Tiny;
use Data::Dumper;
use utf8;

has has_pripara_changed => (
    is       => 'rw',
    isa      => 'Bool',

 view release on metacpan or  search on metacpan

lib/Acme/Pythonic/Functions.pm  view on Meta::CPAN

=item C<pyprint>

Python adds a (system-dependent) newline-character by default to strings to be printed.
This is rather convenient and can be found in the say()-function of Perl 5.10 and above too. I wasn't happy with the way, say() prints lists though. You can have that with something like 'say for @a;', but I like the way, Python prints lists better. ...
If you have to print more complex data-structures, use Data::Dumper.

=back

=head2 String-Functions

 view release on metacpan or  search on metacpan

t/01-encode_decode.t  view on Meta::CPAN

#!perl -T

use Test::More tests => 9;
use Acme::RFC4824;

use Data::Dumper;

my $sfss = Acme::RFC4824->new();
ok(defined $sfss, 'New object creation');

my $test_packet = pack('H*','450000405c1740004006c8500a2581020a2581040185800a0023c8ea61a8d55db012ffff56fe0000020405b4010303000101080a59d6325b0004bbca04020000');

 view release on metacpan or  search on metacpan

lib/Acme/RPC.pm  view on Meta::CPAN

use B::Deparse;
use Continuity;
use IO::Handle;
# use Devel::Pointer;
use JSON;
use Data::Dumper;
use Devel::Caller 'caller_cv';
use PadWalker 'peek_sub';
use Scalar::Util 'blessed';

my $comment = <<'EOF';

 view release on metacpan or  search on metacpan

lib/Acme/ReturnValue.pm  view on Meta::CPAN

use Path::Class qw();
use File::Temp qw(tempdir);
use File::Path;
use File::Copy;
use Archive::Any;
use Data::Dumper;
use JSON;
use Encode;
use Moose;
use List::Util qw(any);

 view release on metacpan or  search on metacpan

lib/Acme/RightSideOutObject.pm  view on Meta::CPAN

blessed hashref object.

One of the most serious flaws of Class::InsideOut is that it encapsulates data,
making it difficult to directly minipulate the object's internal state.
Attempting to inspect the reference to an inside out object with
L<Data::Dumper>, you'll find this:

    $VAR1 = bless( do{\(my $o = undef)}, 'My::Class' );

Fear not!  Acme::RightSideOutObject to the rescue!

 view release on metacpan or  search on metacpan

lib/Acme/RunDoc.pm  view on Meta::CPAN

# 'undef' is Text::Extract::Word's default filter, and probably the only
# one that makes sense.
use constant FILTER => undef;

use Carp qw//;
use Data::Dumper qw//;
use File::Spec;
use IO::File;
use Text::Extract::Word;
use Module::Runtime qw//;