lib/Data/Dumper/Concise.pm

   1 package Data::Dumper::Concise;
   2
   3 use 5.006;
   4
   5 $VERSION = '2.020';
   6
   7 require Exporter;
   8 require Data::Dumper;
   9
  10 BEGIN { @ISA = qw(Exporter) }
  11
  12 @EXPORT = qw(Dumper DumperF DumperObject);
  13
  14 sub DumperObject {
  15   my $dd = Data::Dumper->new([]);
  16   $dd->Terse(1)->Indent(1)->Useqq(1)->Deparse(1)->Quotekeys(0)->Sortkeys(1);
  17 }
  18
  19 sub Dumper { DumperObject->Values([ @_ ])->Dump }
  20
  21 sub DumperF (&@) {
  22   my $code = shift;
  23   return $code->(map Dumper($_), @_);
  24 }
  25
  26 =head1 NAME
  27
  28 Data::Dumper::Concise - Less indentation and newlines plus sub deparsing
  29
  30 =head1 SYNOPSIS
  31
  32   use Data::Dumper::Concise;
  33
  34   warn Dumper($var);
  35
  36 is equivalent to:
  37
  38   use Data::Dumper;
  39   {
  40     local $Data::Dumper::Terse = 1;
  41     local $Data::Dumper::Indent = 1;
  42     local $Data::Dumper::Useqq = 1;
  43     local $Data::Dumper::Deparse = 1;
  44     local $Data::Dumper::Quotekeys = 0;
  45     local $Data::Dumper::Sortkeys = 1;
  46     warn Dumper($var);
  47   }
  48
  49 So for the structure:
  50
  51   { foo => "bar\nbaz", quux => sub { "fleem" } };
  52
  53 Data::Dumper::Concise will give you:
  54
  55   {
  56     foo => "bar\nbaz",
  57     quux => sub {
  58         use warnings;
  59         use strict 'refs';
  60         'fleem';
  61     }
  62   }
  63
  64 instead of the default Data::Dumper output:
  65
  66   $VAR1 = {
  67    'quux' => sub { "DUMMY" },
  68    'foo' => 'bar
  69   baz'
  70   };
  71
  72 (note the tab indentation, oh joy ...)
  73
  74 If you need to get the underlying L<Dumper> object just call C<DumperObject>.
  75
  76 Also try out C<DumperF> which takes a C<CodeRef> as the first argument to
  77 format the output.  For example:
  78
  79   use Data::Dumper::Concise;
  80
  81   warn DumperF { "result: $_[0] result2: $_[1]" } $foo, $bar;
  82
  83 Which is the same as:
  84
  85   warn 'result: ' . Dumper($foo) . ' result2: ' . Dumper($bar);
  86
  87 =head1 DESCRIPTION
  88
  89 This module always exports a single function, Dumper, which can be called
  90 with an array of values to dump those values.
  91
  92 It exists, fundamentally, as a convenient way to reproduce a set of Dumper
  93 options that we've found ourselves using across large numbers of applications,
  94 primarily for debugging output.
  95
  96 The principle guiding theme is "all the concision you can get while still
  97 having a useful dump and not doing anything cleverer than setting Data::Dumper
  98 options" - it's been pointed out to us that Data::Dump::Streamer can produce
  99 shorter output with less lines of code. We know. This is simpler and we've
 100 never seen it segfault. But for complex/weird structures, it generally rocks.
 101 You should use it as well, when Concise is underkill. We do.
 102
 103 Why is deparsing on when the aim is concision? Because you often want to know
 104 what subroutine refs you have when debugging and because if you were planning
 105 to eval this back in you probably wanted to remove subrefs first and add them
 106 back in a custom way anyway. Note that this -does- force using the pure perl
 107 Dumper rather than the XS one, but I've never in my life seen Data::Dumper
 108 show up in a profile so "who cares?".
 109
 110 =head1 BUT BUT BUT ...
 111
 112 Yes, we know. Consider this module in the ::Tiny spirit and feel free to
 113 write a Data::Dumper::Concise::ButWithExtraTwiddlyBits if it makes you
 114 happy. Then tell us so we can add it to the see also section.
 115
 116 =head1 SUGARY SYNTAX
 117
 118 This package also provides:
 119
 120 L<Data::Dumper::Concise::Sugar> - provides Dwarn and DwarnS convenience functions
 121
 122 L<Devel::Dwarn> - shorter form for Data::Dumper::Concise::Sugar
 123
 124 =head1 SEE ALSO
 125
 126 We use for some purposes, and dearly love, the following alternatives:
 127
 128 L<Data::Dump> - prettiness oriented but not amazingly configurable
 129
 130 L<Data::Dump::Streamer> - brilliant. beautiful. insane. extensive. excessive. try it.
 131
 132 L<JSON::XS> - no, really. If it's just plain data, JSON is a great option.
 133
 134 =head1 AUTHOR
 135
 136 mst - Matt S. Trout <mst@shadowcat.co.uk>
 137
 138 =head1 CONTRIBUTORS
 139
 140 frew - Arthur Axel "fREW" Schmidt <frioux@gmail.com>
 141
 142 =head1 COPYRIGHT
 143
 144 Copyright (c) 2010 the Data::Dumper::Concise L</AUTHOR> and L</CONTRIBUTORS>
 145 as listed above.
 146
 147 =head1 LICENSE
 148
 149 This library is free software and may be distributed under the same terms
 150 as perl itself.
 151
 152 =cut
 153
 154 1;