view release on metacpan or search on metacpan
lib/Acme/IEnumerable.pm view on Meta::CPAN
my $base = $self->new();
while (1) {
my $item = $base->();
do {
use Data::Dumper;
warn Dumper[$self->count(sub { warn Data::Dumper::Dumper($_); 1; })];
Carp::cluck "Index out of range for element_at";
} unless ref $item;
return $$item unless $index--;
}
Carp::confess("Impossible");
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
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.
Makefile.PL view on Meta::CPAN
# $OpenGL::Config containing the hash arguments from
# the WriteMakefile() call.
#
};
print CONFIGPM Data::Dumper->Dump( [$config], [qw(Acme::MITHALDU::BleedingOpenGL::Config)] );
print CONFIGPM qq
{
1;
__END__
view release on metacpan or search on metacpan
inc/Inline/C.pm view on Meta::CPAN
package Inline::C;
our $VERSION = '0.76';
use Inline 0.56;
use Config;
use Data::Dumper;
use Carp;
use Cwd qw(cwd abs_path);
use File::Spec;
use constant IS_WIN32 => $^O eq 'MSWin32';
use if !IS_WIN32, Fcntl => ':flock';
inc/Inline/C.pm view on Meta::CPAN
print MF <<END;
use ExtUtils::MakeMaker;
my %options = %\{
END
local $Data::Dumper::Terse = 1;
local $Data::Dumper::Indent = 1;
print MF Data::Dumper::Dumper(\ %options);
print MF <<END;
\};
WriteMakefile(\%options);
view release on metacpan or search on metacpan
lib/Acme/Machi.pm view on Meta::CPAN
use strict;
use warnings;
use IO::Dir;
use File::Spec;
use File::Basename;
use Data::Dumper;
use Cwd;
use Carp;
#import CPAN libs
use namespace::autoclean;
lib/Acme/Machi.pm view on Meta::CPAN
=head2 search_file_from
Using BFS or DFS to search the target from certain directory.
Return: a two-element list:
the first element is boolean value denoting whether the target was found or not.
the second element is the result string outputed from the core module, Data::Dumper.
You may get to know files distribution even better after printing the string.
=cut
sub search_file_from {
ref $_[0] || croak "Oops! Cannot ask non-human to search!";
lib/Acme/Machi.pm view on Meta::CPAN
return 1 if $RESP;
(m/\A\.{1,2}?\z/aa) || $push_front_back->(\@queue, [ $npp, $nd->{$key} ]);
}
}
}
print Data::Dumper->Dump([\$data],[qw% *data %]);
$found;
}
=head1 AUTHOR
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/Marvel/CinematicUniverse/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/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;
}
inc/Spiffy.pm view on Meta::CPAN
# Debugging support
#===============================================================================
sub spiffy_dump {
no warnings;
if ($dump eq 'dumper') {
require Data::Dumper;
$Data::Dumper::Sortkeys = 1;
$Data::Dumper::Indent = 1;
return Data::Dumper::Dumper(@_);
}
require YAML;
$YAML::UseVersion = 0;
return YAML::Dump(@_) . "...\n";
}
view release on metacpan or search on metacpan
PGPSign/PGPSign.pm view on Meta::CPAN
my $data = shift;
my $param = shift;
%param =();
if ($param) {
%param = eval ($param);
{use Data::Dumper; print Dumper(\%param);}
}
$param{Data} = $data;
$param{Armour} = 1;
$param{Clearsign} = 1 unless $param{Clearsign};
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;
lib/Acme/Perl/VM.pm view on Meta::CPAN
ddx([\@_]);
}
sub dump_stack{
require Data::Dumper;
no warnings 'once';
local $Data::Dumper::Indent = 0;
local $Data::Dumper::Terse = TRUE;
local $Data::Dumper::Quotekeys = FALSE;
local $Data::Dumper::Useqq = TRUE;
deb "(%s)\n", join q{,}, map{
# find variable name
my $varname = '';
my $class = $_->class;
lib/Acme/Perl/VM.pm view on Meta::CPAN
$varname .= $padname->PVX . ' ';
}
last;
}
}
$varname . Data::Dumper->Dump([is_scalar($_) ? ${$_->object_2svref} : $_->object_2svref], [$_->ROK ? 'SV' : '*SV']);
}
} @PL_stack;
return;
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';
lib/Acme/RPC.pm view on Meta::CPAN
* Rather than only taking oids to dump/call, also take a path in the tree.
* lazy=1 parameter where the last $tree is re-used rather than re-computed.
* Should switch to our own recurse logic from Data::Dumper to support these other things.
* action=dump on anything; in the case of a coderef, find its source on disc or else deparse it
* action=call on coderefs and blessed objects, with an args parameter, or arg1, arg2, arg3, etc, and a method parameter for blessed objs.
* json will croak if a reference contains objects in side it somewhere. Should handle this gracefully.
* Offer JSON output! Not just Data::Dumper. Do this for action=dump, action=call, and the default tree view.
* If Devel::Leak won't give us refs... have to do an Acme::State style crawl from main::,
but crawling into each sub and looking at its lexicals with PadWalker.
Could make for a nice tree view.
Would also make it easy to filter out the variables that hold refs.
lib/Acme/RPC.pm view on Meta::CPAN
$ob = tryunref($ob, $request) or next;
$ob = tryunobject($ob, $request) or next;
$request->print(eval { to_json($ob, { ascii => 1, allow_unknown => 1, allow_blessed => 1, }, ) } || $@);
} else {
$ob = tryunref($ob, $request) or next;
$request->print("<pre>", Data::Dumper::Dumper($ob), "</pre>\n");
}
}
# Devel::Trace::trace('off') if exists $INC{'Devel/Trace.pm'};
lib/Acme/RPC.pm view on Meta::CPAN
}
if($output and $output eq 'json') {
request->print(eval { to_json(\@ret, { ascii => 1}, ) } || $@);
} else {
my $buf = Data::Dumper::Dumper(\@ret);
$request->print(qq{<pre>$buf</pre>\n});
}
for my $item (@ret) {
# add newly created items to the registry
lib/Acme/RPC.pm view on Meta::CPAN
Gives an index of packages, subroutines, variables in those subroutines, closures in those variables, and so on.
=item C<< output=json >>
Output a JavaScript datastructures (JSON) instead of Perl style L<Data::Dumper> or HTML.
The main index page otherwise prints out HTML (under the assumption that a human will be digging through it)
and other things mostly emit L<Data::Dumper> formatted text.
=item C<< oid=(number) >>
=item C<< path=/path/to/something >>
lib/Acme/RPC.pm view on Meta::CPAN
$buf =~ s{(0x[a-f0-9]{6,})}{<a href="?oid=$1">$1</a>}g;
# $oid =~ m/^0x[0-9a-f]{8,}$/
# my $ob = Devel::Pointer::deref(hex($oid));
my $ob = Devel::Pointer::deref($oid);
my $buf = Data::Dumper::Dumper($ob);
# $buf =~ s{(0x[a-f0-9]{6,})}{<a href="?oid=$1">$1</a>}g;
$request->print(qq{<pre>$buf</pre>\n});
* Accepts posts as well, and handle by data type.
Posts to CODE refs run them with the arguments (attempt to reconstitute object references in the arguments... move to 0x style oids again
to support this).
view release on metacpan or search on metacpan
lib/Acme/Replica.pm view on Meta::CPAN
=head1 SYNOPSIS
use strict;
use warnings;
use Acme::Replica;
use Data::Dumper;
my $scalar = 'sushi';
my $replica = replica_of( $scalar );
print $replica # sushi
print 'Never display this message.' if $replica eq 'sushi';
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//;
lib/Acme/RunDoc.pm view on Meta::CPAN
sub import
{
my ($class, @args) = _args(@_);
my $caller = scalar caller;
local $Data::Dumper::Indent = 0;
while (@args)
{
my $module = shift @args;
my $args = ref $args[0] ? shift @args : undef;
my $eval = sprintf(
"{ package %s; my \@args = %s; Acme::RunDoc->use('%s', \@args); }",
$caller,
ref $args eq 'HASH'
? sprintf('do { my %s; %%$VAR1 }', Data::Dumper::Dumper($args))
: ref $args
? sprintf('do { my %s; @$VAR1 }', Data::Dumper::Dumper($args))
: '()',
$module,
);
eval "$eval; 1" or Carp::croak($@);
}
view release on metacpan or search on metacpan
t/my_code.pl view on Meta::CPAN
my $foo = 42;
print "7 times 6 equals $foo\n";
if ($INC{"Acme/SafetyGoggles.pm"}) {
use Data::Dumper;
$Data::Dumper::Indent = 0;
print Data::Dumper::Dumper(
[ $foo,
Acme::SafetyGoggles->state,
Acme::SafetyGoggles->diff ] );
}