Dump/Trace.pm untested

filter: Statementstmt 0.0% 0 / 167 Branchbran 0.0% 0 / 62 Conditioncond 0.0% 0 / 36 MC/DCmcdc 0.0% 0 / 20 Subroutinesub 0.0% 0 / 25 Podpod 0.0% 0 / 17 totaltotal 0.0% 0 / 327 CC 31 SCAR 30.1
CC
31
Cov
0%
print_call
56.0
return_scalar
42.0
mcall
30.0
CRAP 20.2
1 package Data::Dump::Trace;
2  
3 $VERSION = "0.02";
4  
5 # Todo:
6 # - prototypes
7 # in/out parameters key/value style
8 # - exception
9 # - wrap class
10 # - configurable colors
11 # - show call depth using indentation
12 # - show nested calls sensibly
13 # - time calls
14  
15 use strict;
16  
17 use base 'Exporter';
18 our @EXPORT_OK = qw(call mcall wrap autowrap trace);
19  
20 use Carp qw(croak);
21 use overload ();
22  
23 my %obj_name;
24 my %autowrap_class;
25 my %name_count;
26  
27 sub autowrap {
28 while (@_) {
29 my $class = shift;
30 my $info = shift;
31 $info = { prefix => $info } unless ref($info);
32 for ($info->{prefix}) {
33 unless ($_) {
34 $_ = lc($class);
35 s/.*:://;
36 }
37 $_ = '$' . $_ unless /^\$/;
38 }
39 $autowrap_class{$class} = $info;
40 }
41 }
42  
43 sub wrap {
44 my %arg = @_;
45 my $name = $arg{name} || "func";
46 my $func = $arg{func};
47 my $proto = $arg{proto};
48  
49 return sub {
50 call($name, $func, $proto, @_);
51 } if $func;
52  
53 if (my $obj = $arg{obj}) {
54 $name = '$' . $name unless $name =~ /^\$/;
55 $obj_name{overload::StrVal($obj)} = $name;
56 return bless {
57 name => $name,
58 obj => $obj,
59 proto => $arg{proto},
60 }, "Data::Dump::Trace::Wrapper";
61 }
62  
63 croak("Either the 'func' or 'obj' option must be given");
64 }
65  
66 sub trace {
67 my($symbol, $prototype) = @_;
68 no strict 'refs';
69 no warnings 'redefine';
70 *{$symbol} = wrap(name => $symbol, func => \&{$symbol}, proto => $prototype);
71 }
72  
73 sub call {
74 my $name = shift;
75 my $func = shift;
76 my $proto = shift;
77 my $fmt = Data::Dump::Trace::Call->new($name, $proto, \@_);
78 if (!defined wantarray) {
79 $func->(@_);
80 return $fmt->return_void(\@_);
81 }
82 elsif (wantarray) {
83 return $fmt->return_list(\@_, $func->(@_));
84 }
85 else {
86 return $fmt->return_scalar(\@_, scalar $func->(@_));
87 }
88 }
89  
90 sub mcall {
91 my $o = shift;
92 my $method = shift;
93 my $proto = shift;
94 return if $method eq "DESTROY" && !$o->can("DESTROY");
95 my $oname = ref($o) ? $obj_name{overload::StrVal($o)} || "\$o" : $o;
96 my $fmt = Data::Dump::Trace::Call->new("$oname->$method", $proto, \@_);
97 if (!defined wantarray) {
98 $o->$method(@_);
99 return $fmt->return_void(\@_);
100 }
101 elsif (wantarray) {
102 return $fmt->return_list(\@_, $o->$method(@_));
103 }
104 else {
105 return $fmt->return_scalar(\@_, scalar $o->$method(@_));
106 }
107 }
108  
109 package Data::Dump::Trace::Wrapper;
110  
111 sub AUTOLOAD {
112 my $self = shift;
113 our $AUTOLOAD;
114 my $method = substr($AUTOLOAD, rindex($AUTOLOAD, '::')+2);
115 Data::Dump::Trace::mcall($self->{obj}, $method, $self->{proto}{$method}, @_);
116 }
117  
118 package Data::Dump::Trace::Call;
119  
120 use Term::ANSIColor ();
121 use Data::Dump ();
122  
123 *_dump = \&Data::Dump::dump;
124  
125 our %COLOR = (
126 name => "yellow",
127 output => "cyan",
128 error => "red",
129 debug => "red",
130 );
131  
132 %COLOR = () unless -t STDOUT;
133  
134 sub _dumpav {
135 return "(" . _dump(@_) . ")" if @_ == 1;
136 return _dump(@_);
137 }
138  
139 sub _dumpkv {
140 return _dumpav(@_) if @_ % 2;
141 my %h = @_;
142 my $str = _dump(\%h);
143 $str =~ s/^\{/(/ && $str =~ s/\}\z/)/;
144 return $str;
145 }
146  
147 sub new {
148 my($class, $name, $proto, $input_args) = @_;
149 my $self = bless {
150 name => $name,
151 proto => $proto,
152 }, $class;
153 my $proto_arg = $self->proto_arg;
154 if ($proto_arg =~ /o/) {
155 for (@$input_args) {
156 push(@{$self->{input_av}}, _dump($_));
157 }
158 }
159 else {
160 $self->{input} = $proto_arg eq "%" ? _dumpkv(@$input_args) : _dumpav(@$input_args);
161 }
162 return $self;
163 }
164  
165 sub proto_arg {
166 my $self = shift;
167 my($arg, $ret) = split(/\s*=\s*/, $self->{proto} || "");
168 $arg ||= '@';
169 return $arg;
170 }
171  
172 sub proto_ret {
173 my $self = shift;
174 my($arg, $ret) = split(/\s*=\s*/, $self->{proto} || "");
175 $ret ||= '@';
176 return $ret;
177 }
178  
179 sub color {
180 my($self, $category, $text) = @_;
181 return $text unless $COLOR{$category};
182 return Term::ANSIColor::colored($text, $COLOR{$category});
183 }
184  
185 sub print_call {
186 my $self = shift;
187 my $outarg = shift;
188 print $self->color("name", "$self->{name}");
189 if (my $input = $self->{input}) {
190 $input = "" if $input eq "()" && $self->{name} =~ /->/;
191 print $self->color("input", $input);
192 }
193 else {
194 my $proto_arg = $self->proto_arg;
195 print "(";
196 my $i = 0;
197 for (@{$self->{input_av}}) {
198 print ", " if $i;
199 my $proto = substr($proto_arg, 0, 1, "");
200 if ($proto ne "o") {
201 print $self->color("input", $_);
202 }
203 if ($proto eq "o" || $proto eq "O") {
204 print " = " if $proto eq "O";
205 print $self->color("output", _dump($outarg->[$i]));
206 }
207 }
208 continue {
209 $i++;
210 }
211 print ")";
212 }
213 }
214  
215 sub return_void {
216 my $self = shift;
217 my $arg = shift;
218 $self->print_call($arg);
219 print "\n";
220 return;
221 }
222  
223 sub return_scalar {
224 my $self = shift;
225 my $arg = shift;
226 $self->print_call($arg);
227 my $s = shift;
228 my $name;
229 my $proto_ret = $self->proto_ret;
230 my $wrap = $autowrap_class{ref($s)};
231 if ($proto_ret =~ /^\$\w+\z/ && ref($s) && ref($s) !~ /^(?:ARRAY|HASH|CODE|GLOB)\z/) {
232 $name = $proto_ret;
233 }
234 else {
235 $name = $wrap->{prefix} if $wrap;
236 }
237 if ($name) {
238 $name .= $name_count{$name} if $name_count{$name}++;
239 print " = ", $self->color("output", $name), "\n";
240 $s = Data::Dump::Trace::wrap(name => $name, obj => $s, proto => $wrap->{proto});
241 }
242 else {
243 print " = ", $self->color("output", _dump($s));
244 if (!$s && $proto_ret =~ /!/ && $!) {
245 print " ", $self->color("error", errno($!));
246 }
247 print "\n";
248 }
249 return $s;
250 }
251  
252 sub return_list {
253 my $self = shift;
254 my $arg = shift;
255 $self->print_call($arg);
256 print " = ", $self->color("output", $self->proto_ret eq "%" ? _dumpkv(@_) : _dumpav(@_)), "\n";
257 return @_;
258 }
259  
260 sub errno {
261 my $t = "";
262 for (keys %!) {
263 if ($!{$_}) {
264 $t = $_;
265 last;
266 }
267 }
268 my $n = int($!);
269 return "$t($n) $!";
270 }
271  
272 1;
273  
274 __END__