lib/DB/Hooks/TraceVariable.pm untested

filter: Statementstmt 0.0% 0 / 181 Branchbran 0.0% 0 / 8 Conditioncond 0.0% 0 / 5 MC/DCmcdc 0.0% 0 / 3 Subroutinesub 0.0% 0 / 39 Podpod 0.0% 0 / 36 totaltotal 0.0% 0 / 272 CC 5 SCAR 10.1
CC
5
Cov
0%
access_msg
6.0
ref_name
6.0
EXISTS
6.0
CRAP 2.7
1 { package Logger; sub info{ shift; warn @_, "\n" } }
2  
3 package DB::Hooks::TraceVariable;
4  
5 use strict;
6 use warnings;
7  
8 # use Log::Log4perl;
9 my $logger = bless {}, 'Logger';
10  
11  
12 use DB::Commands qw/ set_command get_command stay /;
13 sub cmd_trace_variable {
14 my( $var ) = shift;
15  
16 return [ stay {},
17 "tie $var, 'DB::Hooks::TraceVariable', \\$var, desc => '$var'",
18 ]
19 }
20  
21 set_command tv => \&cmd_trace_variable, 'trace_variable';
22  
23  
24  
25 our $lvl = 0;
26  
27 sub TIESCALAR {
28 my $class = shift;
29 my $data = shift;
30  
31 local $lvl = 1;
32 my %info = @_;
33 $logger->info( access_msg(
34 $info{ desc }, '&defined'
35 ));
36  
37  
38 my $obj = { data => $$data, @_ };
39  
40 return bless $obj, 'ScalarHistory';
41 }
42  
43 sub TIEHASH {
44 my $class = shift;
45 my $data = shift;
46  
47 local $lvl = 1;
48 my %info = @_;
49 $logger->info( access_msg(
50 $info{ desc }, '&defined'
51 ));
52  
53  
54 my $obj;
55 @{ $obj->{ data } }{ keys %$data } = values %$data;
56 @$obj{ keys %info } = values %info;
57  
58 return bless $obj, 'HashHistory';
59 }
60  
61 sub TIEARRAY {
62 my $class = shift;
63 my $data = shift;
64  
65 local $lvl = 1;
66 my %info = @_;
67 $logger->info( access_msg(
68 $info{ desc }, '&defined'
69 ));
70  
71 my $obj;
72 @{ $obj->{ data } }[ keys @$data ] = values @$data;
73 @$obj{ keys %info } = values %info;
74  
75 return bless $obj, 'ArrayHistory';
76 }
77  
78  
79  
80 sub access_msg {
81 my( $name, $old, $new ) = @_;
82  
83 my( $sub ) = (caller(2+$lvl))[3] // '(main)';
84 my( $file, $line ) = (caller(1+$lvl))[1,2];
85 $old = DB::vis_undef( ref_name( $old ) );
86 $new = @_ > 2 ? ' -> ' .DB::vis_undef( ref_name( $new ) ) : '';
87  
88 # return "Access from $sub ($file:$line) to \e[36m$name\e[0m($DB::instance) value: \e[3;37m$old$new\e[0m";
89 return DB::_c( $name, 36 ).": ".DB::_c( "$old$new", '3;37' ).' '.DB::_c( "at $file:$line", '1;90' );
90 }
91  
92  
93 sub ref_name {
94 map{ ref $_ eq 'REF' || ref $_ eq 'SCALAR' ? '\\'.(tied $$_)->{ desc } : $_ } @_;
95 # map{ ref $_ ? '\\'.(tied $$_)->{ desc } : $_ } @_;
96 }
97  
98  
99  
100 {
101 package # hide the package from the PAUSE indexer
102 ScalarHistory;
103 # my $logger = Log::Log4perl::get_logger( "LogVars" );
104 my $logger = bless {}, 'Logger';
105  
106 *{ ScalarHistory::access_msg } = \&DB::Hooks::TraceVariable::access_msg;
107 *{ ScalarHistory::ref_name } = \&DB::Hooks::TraceVariable::ref_name;
108  
109  
110 sub FETCH {
111 my $self = shift;
112  
113 my $name = $self->{ desc };
114 $logger->info( access_msg( $name, $self->{ data } ) );
115  
116 return $self->{ data };
117 }
118  
119  
120 sub STORE {
121 my( $self, $value ) = @_;
122  
123 my $name = $self->{ desc };
124 $logger->info( access_msg( $name, $self->{ data }, $value ) );
125  
126 $self->{ data } = $value;
127 }
128  
129  
130 sub DESTROY {
131 my $self = shift;
132 }
133  
134  
135 sub UNTIE {
136 my $self = shift;
137 }
138 }
139  
140 {
141 package # hide the package from the PAUSE indexer
142 HashHistory;
143 # my $logger = Log::Log4perl::get_logger( "LogVars" );
144 my $logger = bless {}, 'Logger';
145  
146 *{ HashHistory::access_msg } = \&DB::Hooks::TraceVariable::access_msg;
147 *{ HashHistory::ref_name } = \&DB::Hooks::TraceVariable::ref_name;
148  
149  
150 sub FETCH {
151 my( $self, $key ) = @_;
152  
153 my $name = $self->{ desc };
154 $logger->info( access_msg(
155 "$name\{ $key }", $self->{ data }{ $key }
156 ));
157  
158 return $self->{ data }{ $key };
159 }
160  
161  
162 sub STORE {
163 my( $self, $key, $value ) = @_;
164  
165 my $name = $self->{ desc };
166 $logger->info( access_msg(
167 "$name\{ $key }", $self->{ data }{ $key }, $value
168 ));
169  
170 $self->{ data }{ $key } = $value;
171 }
172  
173  
174 sub DELETE {
175 my( $self, $key ) = @_;
176  
177 my $name = $self->{ desc };
178 $logger->info( access_msg(
179 "$name\{ $key }", $self->{ data }{ $key }, '&DELETE'
180 ));
181  
182 delete $self->{ data }{ $key };
183 }
184  
185  
186 sub CLEAR {
187 my( $self ) = @_;
188  
189 my $name = $self->{ desc };
190 $logger->info( access_msg(
191 $name, '&()'
192 ));
193  
194 %{ $self->{ data } } = ();
195 }
196  
197  
198 sub EXISTS {
199 my( $self, $key ) = @_;
200  
201 my $name = $self->{ desc };
202 my $exists = exists $self->{ data }{ $key };
203 $logger->info( access_msg(
204 "$name\{ $key }", '&'. ($exists?'':'NOT ') .'EXISTS'
205 ));
206  
207 $exists;
208 }
209  
210  
211 sub FIRSTKEY {
212 my( $self ) = @_;
213  
214 keys %{ $self->{ data } }; # reset each() iterator
215 each %{ $self->{ data } };
216 }
217  
218  
219 sub NEXTKEY {
220 my( $self, $lastkey ) = @_;
221  
222 each %{ $self->{ data } };
223 }
224  
225  
226 sub SCALAR {
227 my $self = shift;
228  
229 scalar %{ $self->{ data } };
230 }
231  
232  
233 sub DESTROY {
234 my $self = shift;
235 }
236  
237  
238 sub UNTIE {
239 my $self = shift;
240 }
241 }
242  
243  
244 {
245 package # hide the package from the PAUSE indexer
246 ArrayHistory;
247 # my $logger = Log::Log4perl::get_logger( "LogVars" );
248 my $logger = bless {}, 'Logger';
249  
250 *{ ArrayHistory::access_msg } = \&DB::Hooks::TraceVariable::access_msg;
251 *{ ArrayHistory::ref_name } = \&DB::Hooks::TraceVariable::ref_name;
252  
253  
254 sub FETCH {
255 my( $self, $index ) = @_;
256  
257 my $name = $self->{ desc };
258 $logger->info( access_msg(
259 "$name\[ $index ]", $self->{ data }[ $index ]
260 ));
261  
262 return $self->{ data }[ $index ];
263 }
264  
265  
266 sub STORE {
267 my( $self, $index, $value ) = @_;
268  
269 my $name = $self->{ desc };
270 $logger->info( access_msg(
271 "$name\[ $index ]", $value
272 ));
273  
274 $self->{ data }[ $index ] = $value;
275 }
276  
277  
278 sub DELETE {
279 my( $self, $index ) = @_;
280  
281 my $name = $self->{ desc };
282 $logger->info( access_msg(
283 "$name\[ $index ]", '&DELETE'
284 ));
285  
286 delete $self->{ data }[ $index ];
287 }
288  
289  
290 sub CLEAR {
291 my( $self ) = @_;
292  
293 my $name = $self->{ desc };
294 $logger->info( access_msg(
295 $name, '&()'
296 ));
297  
298 @{ $self->{ data } } = ();
299 }
300  
301  
302 sub EXISTS {
303 my( $self, $index ) = @_;
304  
305 my $name = $self->{ desc };
306 my $exists = exists $self->{ data }[ $index ];
307 $logger->info( access_msg(
308 "$name\[ $index ]", '&'. ($exists?'':'NOT ') .'EXISTS'
309 ));
310  
311 $exists;
312 }
313  
314  
315 sub FETCHSIZE {
316 my $self = shift;
317 my $count = scalar @{ $self->{ data } };
318  
319 my $name = $self->{ desc };
320 $logger->info( access_msg(
321 $name, '&FETCHSIZE '.$count
322 ));
323  
324 $count;
325 }
326  
327  
328 sub STORESIZE {
329 my( $self, $count ) = @_;
330  
331 my $name = $self->{ desc };
332 $logger->info( access_msg(
333 $name, '&STORESIZE ' .$count
334 ));
335  
336 $#{ $self->{ data } } = $count;
337 }
338  
339  
340 sub PUSH {
341 my $self = shift;
342  
343 local $" = ' | ';
344 my $name = $self->{ desc };
345 $logger->info( access_msg(
346 $name, '&PUSH'." @{[ ref_name( @_ ) ]}"
347 ));
348  
349 push @{ $self->{ data } }, @_;
350 }
351  
352  
353 sub POP {
354 my $self = shift;
355  
356 my $name = $self->{ desc };
357 $logger->info( access_msg(
358 $name, '&POP'
359 ));
360  
361 pop @{ $self->{ data } };
362 }
363  
364  
365 sub SHIFT {
366 my $self = shift;
367  
368 my $name = $self->{ desc };
369 $logger->info( access_msg(
370 $name, '&SHIFT'
371 ));
372  
373 shift @{ $self->{ data } };
374 }
375  
376  
377 sub UNSHIFT {
378 my $self = shift;
379  
380 my $name = $self->{ desc };
381 $logger->info( access_msg(
382 $name, '&UNSHIFT'
383 ));
384  
385 unshift @{ $self->{ data } }, @_;
386 }
387  
388  
389 sub SPLICE {
390 my $self = shift;
391  
392 my $name = $self->{ desc };
393 $logger->info( access_msg(
394 $name, '&SPLICE'
395 ));
396  
397 splice @{ $self->{ data } }, @_;
398 }
399  
400  
401 sub EXTEND {
402 # Do nothing
403 return;
404 }
405  
406  
407 sub DESTROY {
408 my $self = shift;
409 }
410  
411  
412 sub UNTIE {
413 my $self = shift;
414 }
415 }
416  
417 1;
418  
419  
420 __END__