lib/Data/Dumper/Concise.pm

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