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
local/lib/perl5/Module/Build/Compat.pm view on Meta::CPAN
use File::Spec;
use Config;
use Module::Build;
use Module::Metadata;
use version;
use Data::Dumper;
my %convert_installdirs = (
PERL => 'core',
SITE => 'site',
VENDOR => 'vendor',
local/lib/perl5/Module/Build/Compat.pm view on Meta::CPAN
if ($build->recursive_test_files) {
$MM_Args{test} = { TESTS => join q{ }, $package->_test_globs($build) };
}
local $Data::Dumper::Terse = 1;
my $args = Data::Dumper::Dumper(\%MM_Args);
$args =~ s/\{(.*)\}/($1)/s;
print $fh <<"EOF";
use ExtUtils::MakeMaker;
WriteMakefile
view release on metacpan or search on metacpan
lib/Acme/Spinodal/Utils.pm view on Meta::CPAN
sub sum {
my $total;
my $num = shift // 0;
use Data::Dumper;
$total = _check_number($num);
while( (defined ($num = shift)) && (defined _check_number( $num )) ){
$total *= $num;
}
view release on metacpan or search on metacpan
lib/Acme/State.pm view on Meta::CPAN
}
}
return $node;
}->('main::');
# use Data::Dumper; print "debug: ", Data::Dumper::Dumper($tree), "\n";
local $Storable::Deparse = $wantcoderefs;
my $save_fn = save_file_name();
lib/Acme/State.pm view on Meta::CPAN
You *could* just store your data in the Ether with Memcached.
You could C<INSERT> and C<UPDATE> manually against a database to store every little tidbit and factoid
as they're computed.
You could use BerekelyDB, including the build-in legacy C<dbmopen> and mangle everything
down to a flat associative list.
You could use L<Data::Dumper> to write a structure to a file and C<eval> that on startup
and keep all of your precious application data in one big datastructure and still not be able to
persist entire objects.
You could use C<dump> and keep waiting for the day that someone finally writes C<undump>.
But what's the fun in that?
view release on metacpan or search on metacpan
DateLocales.pm view on Meta::CPAN
our $VERSION = '0.03';
use base qw(Exporter);
our @EXPORT = qw(weekday_and_month_names_dump);
use Data::Dumper qw(Dumper);
use File::Spec::Functions qw(file_name_is_absolute);
use POSIX qw(strftime);
sub all_locales {
my @res;
DateLocales.pm view on Meta::CPAN
}
my %register;
my $fingerprint_data = sub {
my($ref) = @_;
local $Data::Dumper::Indent = 0;
local $Data::Dumper::Useqq = 0;
local $Data::Dumper::Sortkeys = 1;
Dumper($ref);
};
my $register_and_use_data = sub {
my($ref, $name) = @_;
my $fingerprint = $fingerprint_data->($ref);
DateLocales.pm view on Meta::CPAN
}
sub weekday_and_month_names_dump {
my @res = weekday_and_month_names();
join "\n", map {
Data::Dumper->new([$_],['r'])->Useqq(1)->Indent(0)->Sortkeys(1)->Dump
} @res;
}
# REPO BEGIN
sub _is_in_path {
view release on metacpan or search on metacpan
t/01-function.t view on Meta::CPAN
use lib './lib';
use Acme::Syntax::Python;
from Data::Dumper import Dumper, DumperX;
import Test::More;
def test:
ok(1, "Functions Working");
view release on metacpan or search on metacpan
lib/Acme/SysPath.pm view on Meta::CPAN
use Acme::SysPath;
print Acme::SysPath->config;
print Acme::SysPath->template;
print Acme::SysPath->image;
use Data::Dumper; print "dump> ", Dumper(Acme::SysPath->paths), "\n";
=head1 FUNCTIONS
=head2 paths
view release on metacpan or search on metacpan
lib/Acme/Takahashi/Method.pm view on Meta::CPAN
}
sub import{
my $pkg = shift;
my %arg = @_;
#use Data::Dumper;
#print Dumper \%args;
my $columns = $arg{columns} || 80;
my $rows = $arg{rows} || 24;
my $show_slide = !$arg{noslideshow} || 1;
$arg{debug} and $DEBUG = 1;
view release on metacpan or search on metacpan
lib/Acme/TextLayout.pm view on Meta::CPAN
use warnings;
use strict;
use Perl6::Attributes;
use FileHandle;
use Data::Dumper;
=head1 NAME
Acme::TextLayout - Layout things in a grid, as described textually
view release on metacpan or search on metacpan
t/lib/IO/String.pm view on Meta::CPAN
return $old;
}
sub dump
{
require Data::Dumper;
my $self = shift;
print Data::Dumper->Dump([$self], ['*self']);
print Data::Dumper->Dump([*$self{HASH}], ['$self{HASH}']);
return;
}
sub TIEHANDLE
{
view release on metacpan or search on metacpan
return join("\n",@tabout)."\n";
}
=head2 serialize
Returns a data structure as a string. See also C<Data::Dumper>
(serialize was created long time ago before Data::Dumper appeared on
CPAN, before CPAN even...)
B<Input:> One to four arguments.
First argument: A reference to the structure you want.
view release on metacpan or search on metacpan
lib/Acme/URM.pm view on Meta::CPAN
package Acme::URM;
use strict;
use Data::Dumper;
our $VERSION = '0.02';
use constant LAST => -1;
use constant THIS => -2;
view release on metacpan or search on metacpan
lib/Acme/VarMess.pm view on Meta::CPAN
package Acme::VarMess;
use strict;
use PPI;
use Data::Dumper;
use List::Util qw(shuffle);
use Digest::MD5 qw(md5_hex);
require Exporter;
our @ISA = qw(Exporter);
our @EXPORT = qw(blow);
view release on metacpan or search on metacpan
lib/Acme/Your.pm view on Meta::CPAN
Acme::Your - not our variables, your variables
=head1 SYNOPSIS
use Data::Dumper;
use Acme::Your "Data::Dumper";
your $Varname; # This is really $Data::Dumper::Varname
print "The default variable name for DD is $Varname";
=head1 DESCRIPTION
view release on metacpan or search on metacpan
examples/Synopsis.pl view on Meta::CPAN
use lib "$Bin/../lib";
use 5.010;
use strict;
use warnings;
use Acpi::Class;
use Data::Dumper;
#}}}
my $class = Acpi::Class->new( class => 'power_supply');
my $devices = $class->g_devices;
print "Power devices: ";
view release on metacpan or search on metacpan
lib/Acrux/Util.pm view on Meta::CPAN
=head2 dumper
my $perl = dumper({some => 'data'});
Dump a Perl data structure with L<Data::Dumper>
=head2 eqtime
eqtime("from/file", "to/file") or die "Oops";
lib/Acrux/Util.pm view on Meta::CPAN
use IO::File qw//;
use Term::ANSIColor qw/ colored /;
use POSIX qw/ :fcntl_h ceil floor strftime /;
use Fcntl qw/ O_WRONLY O_CREAT O_APPEND O_EXCL SEEK_END /;
use Time::Local;
use Data::Dumper qw//;
use Storable qw/dclone/;
use Acrux::Const qw/ IS_TTY DATE_FORMAT DATETIME_FORMAT /;
use base qw/Exporter/;
lib/Acrux/Util.pm view on Meta::CPAN
# Common
sub deprecated {
local $Carp::CarpLevel = 1;
$ENV{ACRUX_FATAL_DEPRECATIONS} ? croak @_ : carp @_;
}
sub dumper { Data::Dumper->new([@_])->Indent(1)->Sortkeys(1)->Terse(1)->Useqq(1)->Dump }
sub clone { dclone(shift) }
sub load_class {
my $class = shift // '';
return "Invalid class name: $class" unless $class =~ /^\w(?:[\w:]*\w)?$/;
return undef if $class->can('new') || eval "require $class; 1"; # Ok
view release on metacpan or search on metacpan
bin/activator.pl view on Meta::CPAN
use Activator::Registry;
use Activator::Config;
use Activator::Log qw( :levels );
use Exception::Class::TryCatch;
use Data::Dumper;
use Template;
use File::Find;
=head1 NAME
view release on metacpan or search on metacpan
t/08-basic.t view on Meta::CPAN
use strict;
use warnings;
no warnings 'redefine';
use 5.010;
use Data::Dumper;
use FindBin '$Bin';
use lib "$Bin/../lib";
package t::class;
view release on metacpan or search on metacpan
test/delete_process_instance.pl view on Meta::CPAN
#!/usr/bin/env perl
use FindBin;
use lib "$FindBin::Bin/../lib";
use Activiti::Rest::Client;
use Data::Dumper;
binmode STDOUT,":utf8";
my $client = Activiti::Rest::Client->new(
url => 'http://rest:rest@andric.ugent.be:8888/activiti-rest/service'
view release on metacpan or search on metacpan
lib/Adapter/Async/Model.pm view on Meta::CPAN
use Log::Any qw($log);
use Future;
use Module::Load;
use Data::Dumper;
use Variable::Disposition qw(retain_future);
=head2 import
=over 4
view release on metacpan or search on metacpan
lib/Addr/MyIP.pm view on Meta::CPAN
package Addr::MyIP;
use strict;
use warnings;
use Data::Dumper;
use Exporter qw(import);
use HTTP::Tiny;
our $VERSION = '0.05';
view release on metacpan or search on metacpan
lib/Address/PostCode/Australia.pm view on Meta::CPAN
=cut
use 5.006;
use JSON;
use Data::Dumper;
use Address::PostCode::UserAgent;
use Address::PostCode::Australia::Place;
use Address::PostCode::Australia::Params qw(validate);
use Moo;
view release on metacpan or search on metacpan
lib/Address/PostCode/India.pm view on Meta::CPAN
=cut
use 5.006;
use JSON;
use Data::Dumper;
use Address::PostCode::UserAgent;
use Address::PostCode::India::Place;
use Moo;
use namespace::autoclean;
view release on metacpan or search on metacpan
lib/Address/PostCode/UK.pm view on Meta::CPAN
=cut
use 5.006;
use JSON;
use Data::Dumper;
use Address::PostCode::UserAgent;
use Address::PostCode::UK::Location;
use Address::PostCode::UK::Place;
use Address::PostCode::UK::Place::Geo;
use Address::PostCode::UK::Place::Ward;
view release on metacpan or search on metacpan
lib/Address/PostCode/UserAgent.pm view on Meta::CPAN
Version 0.09
=cut
use 5.006;
use Data::Dumper;
use HTTP::Tiny;
use Address::PostCode::UserAgent::Exception;
use Moo;
view release on metacpan or search on metacpan
lib/AddressBook/DB/BBDB.pm view on Meta::CPAN
]
After this is decoded it will be returned as a reference to a BBDB
object. The internal structure of the BBDB object mimics the lisp
structure of the BBDB string. It consists of a reference to an array
with 9 elements The Data::Dumper output of the above BBDB string would
just replaces all of the ()s with []s. It can be accessed by using
the C<$bbdb->part('all')> method.
=head2 Methods
view release on metacpan or search on metacpan
lib/Bundle/Advent/Year2000.pm view on Meta::CPAN
$ cpan Bundle::Advent::Year2000
=head1 CONTENTS
Data::Dumper - L<pod|Data::Dumper>, L<http://www.perladvent.org/2000/01/>
LWP::Simple - L<pod|LWP::Simple>, L<http://www.perladvent.org/2000/02/>
POE::Component::IRC - L<pod|POE::Component::IRC>, L<http://www.perladvent.org/2000/03/>
view release on metacpan or search on metacpan
Infix2Postfix.pm view on Meta::CPAN
package Affix::Infix2Postfix;
use strict;
use vars qw($VERSION @ISA @EXPORT @EXPORT_OK);
#use Data::Dumper;
require Exporter;
require AutoLoader;
@ISA = qw(Exporter AutoLoader);
view release on metacpan or search on metacpan
lib/Affix.pm view on Meta::CPAN
For example on a UNIX-like operating system, you could use the following code
to print the home directory of the current user:
use Affix;
use Data::Dumper;
typedef PwStruct => Struct [
name => Str, # username
pass => Str, # hashed pass if shadow db isn't in use
uuid => UInt, # user
guid => UInt, # group
view release on metacpan or search on metacpan
package Agent;
use strict;
use UNIVERSAL;
use Class::Tom qw( cc repair );
use Data::Dumper; # for argument passing
use Agent::Message; # load message handling routines
use Agent::Transport; # load the autoloader
use vars qw($VERSION $MAJORVERSION $MINORVERSION $MICROVERSION $thread $Debug);