X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FData%2FDumper%2FConcise%2FSugar.pm;h=f82754a249af945f1ceacfccb36c460034683c1e;hb=2566c738d28b5c6fd48615bd8a7a297d3e92cffd;hp=addd8e25f24bb8f9aa883af5766088017cf966bc;hpb=012236322bb8a135a0e1712b380ca9c3f55d2524;p=p5sagit%2FData-Dumper-Concise.git

diff --git a/lib/Data/Dumper/Concise/Sugar.pm b/lib/Data/Dumper/Concise/Sugar.pm
index addd8e2..f82754a 100644
--- a/lib/Data/Dumper/Concise/Sugar.pm
+++ b/lib/Data/Dumper/Concise/Sugar.pm
@@ -7,12 +7,43 @@ use Data::Dumper::Concise ();
 
 BEGIN { @ISA = qw(Exporter) }
 
-@EXPORT = qw(Dwarn DwarnS);
+@EXPORT = qw(
+   $Dwarn $DwarnN Dwarn DwarnS DwarnL DwarnN
+   $Ddie $DdieN Ddie DdieS DdieL DdieN DdieD
+);
 
-sub Dwarn { warn Data::Dumper::Concise::Dumper @_; @_ }
+sub Dwarn { return DwarnL(@_) if wantarray; DwarnS($_[0]) }
+
+our $Dwarn = \&Dwarn;
+our $DwarnN = \&DwarnN;
+
+sub DwarnL { warn Data::Dumper::Concise::Dumper @_; @_ }
 
 sub DwarnS ($) { warn Data::Dumper::Concise::Dumper $_[0]; $_[0] }
 
+sub DwarnN ($) {
+   require Devel::ArgNames;
+   my $x = Devel::ArgNames::arg_names();
+   warn(($x?$x:'(anon)') . ' => ' . Data::Dumper::Concise::Dumper $_[0]); $_[0]
+}
+
+sub DwarnF (&@) { my $c = shift; warn &Data::Dumper::Concise::DumperF($c, @_); @_ }
+
+sub Ddie { DdieL(@_) if wantarray; DdieS($_[0]) }
+
+our $Ddie = \&Ddie;
+our $DdieN = \&DdieN;
+
+sub DdieL { die Data::Dumper::Concise::Dumper @_ }
+
+sub DdieS ($) { die Data::Dumper::Concise::Dumper $_[0] }
+
+sub DdieN ($) {
+   require Devel::ArgNames;
+   my $x = Devel::ArgNames::arg_names();
+   die(($x?$x:'(anon)') . ' => ' . Data::Dumper::Concise::Dumper $_[0]);
+}
+
 =head1 NAME
 
 Data::Dumper::Concise::Sugar - return Dwarn @return_value
@@ -27,9 +58,15 @@ is equivalent to:
 
   use Data::Dumper::Concise;
 
-  my @return = some_call(...);
-  warn Dumper(@return);
-  return @return;
+  if (wantarray) {
+     my @return = some_call(...);
+     warn Dumper(@return);
+     return @return;
+  } else {
+     my $return = some_call(...);
+     warn Dumper($return);
+     return $return;
+  }
 
 but shorter. If you need to force scalar context on the value,
 
@@ -45,32 +82,132 @@ is equivalent to:
   warn Dumper($return);
   return $return;
 
-Another trick that is extremely useful when doing method chaining is the
-following:
+If you need to force list context on the value,
 
-  my $foo = Bar->new;
-  $foo->bar->baz->Data::Dumper::Concise::Sugar::DwarnS->biff;
+  use Data::Dumper::Concise::Sugar;
 
-which is the same as:
+  return DwarnL some_call(...)
 
-  my $foo = Bar->new;
-  (DwarnS $foo->bar->baz)->biff;
+is equivalent to:
+
+  use Data::Dumper::Concise;
+
+  my @return = some_call(...);
+  warn Dumper(@return);
+  return @return;
+
+If you want to label your output, try DwarnN
+
+  use Data::Dumper::Concise::Sugar;
+
+  return DwarnN $foo
+
+is equivalent to:
+
+  use Data::Dumper::Concise;
+
+  my @return = some_call(...);
+  warn '$foo => ' . Dumper(@return);
+  return @return;
+
+If you want to output a reference returned by a method easily, try $Dwarn
+
+ $foo->bar->{baz}->$Dwarn
+
+is equivalent to:
+
+  my $return = $foo->bar->{baz};
+  warn Dumper($return);
+  return $return;
+
+If you want to format the output of your data structures, try DwarnF
+
+ my ($a, $c) = DwarnF { "awesome: $_[0] not awesome: $_[1]" } $awesome, $cheesy;
+
+is equivalent to:
+
+  my @return = ($awesome, $cheesy);
+  warn DumperF { "awesome: $_[0] not awesome: $_[1]" } $awesome, $cheesy;
+  return @return;
+
+If you want to immediately die after outputting the data structure, every
+Dwarn subroutine has a paired Ddie version, so just replace the warn with die.
+For example:
+
+ DdieL 'foo', { bar => 'baz' };
 
 =head1 DESCRIPTION
 
   use Data::Dumper::Concise::Sugar;
 
-will import Dwarn and DwarnS into your namespace. Using L<Exporter>, so see
-its docs for ways to make it do something else.
+will import Dwarn, $Dwarn, DwarnL, DwarnN, and DwarnS into your namespace. Using
+L<Exporter>, so see its docs for ways to make it do something else.
 
 =head2 Dwarn
 
+  sub Dwarn { return DwarnL(@_) if wantarray; DwarnS($_[0]) }
+
+=head2 $Dwarn
+
+  $Dwarn = \&Dwarn
+
+=head2 $DwarnN
+
+  $DwarnN = \&DwarnN
+
+=head2 DwarnL
+
   sub Dwarn { warn Data::Dumper::Concise::Dumper @_; @_ }
 
-=head3 DwarnS
+=head2 DwarnS
 
   sub DwarnS ($) { warn Data::Dumper::Concise::Dumper $_[0]; $_[0] }
 
+=head2 DwarnN
+
+  sub DwarnN { warn '$argname => ' . Data::Dumper::Concise::Dumper $_[0]; $_[0] }
+
+B<Note>: this requires L<Devel::ArgNames> to be installed.
+
+=head2 DwarnF
+
+  sub DwarnF (&@) { my $c = shift; warn &Data::Dumper::Concise::DumperF($c, @_); @_ }
+
+=head1 TIPS AND TRICKS
+
+=head2 global usage
+
+Instead of always just doing:
+
+  use Data::Dumper::Concise::Sugar;
+
+  Dwarn ...
+
+We tend to do:
+
+  perl -MData::Dumper::Concise::Sugar foo.pl
+
+(and then in the perl code:)
+
+  ::Dwarn ...
+
+That way, if you leave them in and run without the
+C<< use Data::Dumper::Concise::Sugar >> the program will fail to compile and
+you are less likely to check it in by accident.  Furthmore it allows that
+much less friction to add debug messages.
+
+=head2 method chaining
+
+One trick which is useful when doing method chaining is the following:
+
+  my $foo = Bar->new;
+  $foo->bar->baz->Data::Dumper::Concise::Sugar::DwarnS->biff;
+
+which is the same as:
+
+  my $foo = Bar->new;
+  (DwarnS $foo->bar->baz)->biff;
+
 =head1 SEE ALSO
 
 You probably want L<Devel::Dwarn>, it's the shorter name for this module.