File Coverage

lib/Template/Stash.pm
Criterion Covered Total %
statement 154 191 80.6
branch 98 148 66.2
condition 54 87 62.0
subroutine 18 21 85.7
pod 9 9 100.0
total 333 456 73.0


line stmt bran cond sub pod time code
1             #============================================================= -*-Perl-*-
2             #
3             # Template::Stash
4             #
5             # DESCRIPTION
6             # Definition of an object class which stores and manages access to
7             # variables for the Template Toolkit.
8             #
9             # AUTHOR
10             # Andy Wardley
11             #
12             # COPYRIGHT
13             # Copyright (C) 1996-2007 Andy Wardley. All Rights Reserved.
14             #
15             # This module is free software; you can redistribute it and/or
16             # modify it under the same terms as Perl itself.
17             #
18             #============================================================================
19              
20             package Template::Stash;
21              
22 80     80   4146 use strict;
  80         174  
  80         2586  
23 80     80   482 use warnings;
  80         160  
  80         2040  
24 80     80   42802 use Template::VMethods;
  80         5113  
  80         3247  
25 80     80   1384 use Template::Exception;
  80         183  
  80         2088  
26 80     80   440 use Scalar::Util qw( blessed reftype );
  80         168  
  80         330871  
27              
28             our $VERSION = 2.91;
29             our $DEBUG = 0 unless defined $DEBUG;
30             our $PRIVATE = qr/^[_.]/;
31             our $UNDEF_TYPE = 'var.undef';
32             our $UNDEF_INFO = 'undefined variable: %s';
33              
34             # alias _dotop() to dotop() so that we have a consistent method name
35             # between the Perl and XS stash implementations
36             *dotop = \&_dotop;
37              
38              
39             #------------------------------------------------------------------------
40             # Virtual Methods
41             #
42             # If any of $ROOT_OPS, $SCALAR_OPS, $HASH_OPS or $LIST_OPS are already
43             # defined then we merge their contents with the default virtual methods
44             # define by Template::VMethods. Otherwise we can directly alias the
45             # corresponding Template::VMethod package vars.
46             #------------------------------------------------------------------------
47              
48             our $ROOT_OPS = defined $ROOT_OPS
49             ? { %{$Template::VMethods::ROOT_VMETHODS}, %$ROOT_OPS }
50             : $Template::VMethods::ROOT_VMETHODS;
51              
52             our $SCALAR_OPS = defined $SCALAR_OPS
53             ? { %{$Template::VMethods::TEXT_VMETHODS}, %$SCALAR_OPS }
54             : $Template::VMethods::TEXT_VMETHODS;
55              
56             our $HASH_OPS = defined $HASH_OPS
57             ? { %{$Template::VMethods::HASH_VMETHODS}, %$HASH_OPS }
58             : $Template::VMethods::HASH_VMETHODS;
59              
60             our $LIST_OPS = defined $LIST_OPS
61             ? { %{$Template::VMethods::LIST_VMETHODS}, %$LIST_OPS }
62             : $Template::VMethods::LIST_VMETHODS;
63              
64              
65             #------------------------------------------------------------------------
66             # define_vmethod($type, $name, \&sub)
67             #
68             # Defines a virtual method of type $type (SCALAR, HASH, or LIST), with
69             # name $name, that invokes &sub when called. It is expected that &sub
70             # be able to handle the type that it will be called upon.
71             #------------------------------------------------------------------------
72              
73             sub define_vmethod {
74 8     8 1 22 my ($class, $type, $name, $sub) = @_;
75 8         13 my $op;
76 8         19 $type = lc $type;
77              
78 8 100       95 if ($type =~ /^scalar|item$/) {
    100          
    50          
79 1         3 $op = $SCALAR_OPS;
80             }
81             elsif ($type eq 'hash') {
82 3         7 $op = $HASH_OPS;
83             }
84             elsif ($type =~ /^list|array$/) {
85 4         10 $op = $LIST_OPS;
86             }
87             else {
88 0         0 die "invalid vmethod type: $type\n";
89             }
90              
91 8         29 $op->{ $name } = $sub;
92              
93 8         25 return 1;
94             }
95              
96              
97             #========================================================================
98             # ----- CLASS METHODS -----
99             #========================================================================
100              
101             #------------------------------------------------------------------------
102             # new(\%params)
103             #
104             # Constructor method which creates a new Template::Stash object.
105             # An optional hash reference may be passed containing variable
106             # definitions that will be used to initialise the stash.
107             #
108             # Returns a reference to a newly created Template::Stash.
109             #------------------------------------------------------------------------
110              
111             sub new {
112 157     157 1 642 my $class = shift;
113 157 50       690 my $params = ref $_[0] eq 'HASH' ? shift(@_) : { @_ };
114              
115 157         1848 my $self = {
116             global => { },
117             %$params,
118             %$ROOT_OPS,
119             '_PARENT' => undef,
120             };
121              
122 157         2545 bless $self, $class;
123             }
124              
125              
126             #========================================================================
127             # ----- PUBLIC OBJECT METHODS -----
128             #========================================================================
129              
130             #------------------------------------------------------------------------
131             # clone(\%params)
132             #
133             # Creates a copy of the current stash object to effect localisation
134             # of variables. The new stash is blessed into the same class as the
135             # parent (which may be a derived class) and has a '_PARENT' member added
136             # which contains a reference to the parent stash that created it
137             # ($self). This member is used in a successive declone() method call to
138             # return the reference to the parent.
139             #
140             # A parameter may be provided which should reference a hash of
141             # variable/values which should be defined in the new stash. The
142             # update() method is called to define these new variables in the cloned
143             # stash.
144             #
145             # Returns a reference to a cloned Template::Stash.
146             #------------------------------------------------------------------------
147              
148             sub clone {
149 1484     1484 1 3217 my ($self, $params) = @_;
150 1484   100     3813 $params ||= { };
151              
152             # look out for magical 'import' argument which imports another hash
153 1484         3097 my $import = $params->{ import };
154 1484 100 66     4883 if (defined $import && ref $import eq 'HASH') {
155 1         4 delete $params->{ import };
156             }
157             else {
158 1483         2513 undef $import;
159             }
160              
161 1484         35438 my $clone = bless {
162             %$self, # copy all parent members
163             %$params, # copy all new data
164             '_PARENT' => $self, # link to parent
165             }, ref $self;
166            
167             # perform hash import if defined
168 1484 100       7780 &{ $HASH_OPS->{ import } }($clone, $import)
  1         8  
169             if defined $import;
170              
171 1484         6526 return $clone;
172             }
173              
174            
175             #------------------------------------------------------------------------
176             # declone($export)
177             #
178             # Returns a reference to the PARENT stash. When called in the following
179             # manner:
180             # $stash = $stash->declone();
181             # the reference count on the current stash will drop to 0 and be "freed"
182             # and the caller will be left with a reference to the parent. This
183             # contains the state of the stash before it was cloned.
184             #------------------------------------------------------------------------
185              
186             sub declone {
187 1484     1484 1 2219 my $self = shift;
188 1484 50       9239 $self->{ _PARENT } || $self;
189             }
190              
191              
192             #------------------------------------------------------------------------
193             # get($ident)
194             #
195             # Returns the value for an variable stored in the stash. The variable
196             # may be specified as a simple string, e.g. 'foo', or as an array
197             # reference representing compound variables. In the latter case, each
198             # pair of successive elements in the list represent a node in the
199             # compound variable. The first is the variable name, the second a
200             # list reference of arguments or 0 if undefined. So, the compound
201             # variable [% foo.bar('foo').baz %] would be represented as the list
202             # [ 'foo', 0, 'bar', ['foo'], 'baz', 0 ]. Returns the value of the
203             # identifier or an empty string if undefined. Errors are thrown via
204             # die().
205             #------------------------------------------------------------------------
206              
207             sub get {
208 596     596 1 2646 my ($self, $ident, $args) = @_;
209 596         714 my ($root, $result);
210 596         752 $root = $self;
211              
212 596 100 100     2875 if (ref $ident eq 'ARRAY'
  14   66     28  
213             || ($ident =~ /\./)
214 14         53 && ($ident = [ map { s/\(.*$//; ($_, 0) } split(/\./, $ident) ])) {
215 305         534 my $size = $#$ident;
216              
217             # if $ident is a list reference, then we evaluate each item in the
218             # identifier against the previous result, using the root stash
219             # ($self) as the first implicit 'result'...
220            
221 305         886 foreach (my $i = 0; $i <= $size; $i += 2) {
222 673         2472 $result = $self->_dotop($root, @$ident[$i, $i+1]);
223 672 100       1632 last unless defined $result;
224 664         2046 $root = $result;
225             }
226             }
227             else {
228 291         852 $result = $self->_dotop($root, $ident, $args);
229             }
230              
231 593 100       2382 return defined $result
232             ? $result
233             : $self->undefined($ident, $args);
234             }
235              
236              
237             #------------------------------------------------------------------------
238             # set($ident, $value, $default)
239             #
240             # Updates the value for a variable in the stash. The first parameter
241             # should be the variable name or array, as per get(). The second
242             # parameter should be the intended value for the variable. The third,
243             # optional parameter is a flag which may be set to indicate 'default'
244             # mode. When set true, the variable will only be updated if it is
245             # currently undefined or has a false value. The magical 'IMPORT'
246             # variable identifier may be used to indicate that $value is a hash
247             # reference whose values should be imported. Returns the value set,
248             # or an empty string if not set (e.g. default mode). In the case of
249             # IMPORT, returns the number of items imported from the hash.
250             #------------------------------------------------------------------------
251              
252             sub set {
253 491     491 1 1646 my ($self, $ident, $value, $default) = @_;
254 491         496 my ($root, $result, $error);
255              
256 491         628 $root = $self;
257              
258 2         3 ELEMENT: {
259 491 100 100     533 if (ref $ident eq 'ARRAY'
  491   66     2325  
260             || ($ident =~ /\./)
261 2         10 && ($ident = [ map { s/\(.*$//; ($_, 0) }
262             split(/\./, $ident) ])) {
263            
264             # a compound identifier may contain multiple elements (e.g.
265             # foo.bar.baz) and we must first resolve all but the last,
266             # using _dotop() with the $lvalue flag set which will create
267             # intermediate hashes if necessary...
268 9         19 my $size = $#$ident;
269 9         37 foreach (my $i = 0; $i < $size - 2; $i += 2) {
270 11         42 $result = $self->_dotop($root, @$ident[$i, $i+1], 1);
271 11 50       49 last ELEMENT unless defined $result;
272 11         34 $root = $result;
273             }
274            
275             # then we call _assign() to assign the value to the last element
276 9         35 $result = $self->_assign($root, @$ident[$size-1, $size],
277             $value, $default);
278             }
279             else {
280 482         1351 $result = $self->_assign($root, $ident, 0, $value, $default);
281             }
282             }
283            
284 491 100       1835 return defined $result ? $result : '';
285             }
286              
287              
288             #------------------------------------------------------------------------
289             # getref($ident)
290             #
291             # Returns a "reference" to a particular item. This is represented as a
292             # closure which will return the actual stash item when called.
293             #------------------------------------------------------------------------
294              
295             sub getref {
296 6     6 1 63 my ($self, $ident, $args) = @_;
297 6         13 my ($root, $item, $result);
298 6         8 $root = $self;
299              
300 6 100       50 if (ref $ident eq 'ARRAY') {
301 3         6 my $size = $#$ident;
302            
303 3         11 foreach (my $i = 0; $i <= $size; $i += 2) {
304 6         15 ($item, $args) = @$ident[$i, $i + 1];
305 6 100       20 last if $i >= $size - 2; # don't evaluate last node
306             last unless defined
307 3 50       11 ($root = $self->_dotop($root, $item, $args));
308             }
309             }
310             else {
311 3         7 $item = $ident;
312             }
313            
314 6 50       14 if (defined $root) {
315 11 100   11   98 return sub { my @args = (@{$args||[]}, @_);
  11         57  
316 11         82 $self->_dotop($root, $item, \@args);
317             }
318 6         87 }
319             else {
320 0     0   0 return sub { '' };
  0         0  
321             }
322             }
323              
324              
325              
326              
327             #------------------------------------------------------------------------
328             # update(\%params)
329             #
330             # Update multiple variables en masse. No magic is performed. Simple
331             # variable names only.
332             #------------------------------------------------------------------------
333              
334             sub update {
335 1294     1294 1 2280 my ($self, $params) = @_;
336              
337             # look out for magical 'import' argument to import another hash
338 1294         2775 my $import = $params->{ import };
339 1294 100 66     4560 if (defined $import && ref $import eq 'HASH') {
340 1         4 @$self{ keys %$import } = values %$import;
341 1         4 delete $params->{ import };
342             }
343              
344 1294         5528 @$self{ keys %$params } = values %$params;
345             }
346              
347              
348             #------------------------------------------------------------------------
349             # undefined($ident, $args)
350             #
351             # Method called when a get() returns an undefined value. Can be redefined
352             # in a subclass to implement alternate handling.
353             #------------------------------------------------------------------------
354              
355             sub undefined {
356 1429     1429 1 7361 my ($self, $ident, $args) = @_;
357              
358 1429 100       4178 if ($self->{ _STRICT }) {
359             # Sorry, but we can't provide a sensible source file and line without
360             # re-designing the whole architecture of TT (see TT3)
361             die Template::Exception->new(
362             $UNDEF_TYPE,
363             sprintf(
364             $UNDEF_INFO,
365             $self->_reconstruct_ident($ident)
366             )
367 11 50       45 ) if $self->{ _STRICT };
368             }
369             else {
370             # There was a time when I thought this was a good idea. But it's not.
371 1418         9621 return '';
372             }
373             }
374              
375             sub _reconstruct_ident {
376 11     11   12 my ($self, $ident) = @_;
377 11         10 my ($name, $args, @output);
378 11 100       33 my @input = ref $ident eq 'ARRAY' ? @$ident : ($ident);
379              
380 11         23 while (@input) {
381 15         20 $name = shift @input;
382 15   100     44 $args = shift @input || 0;
383 15 100 66     41 $name .= '(' . join(', ', map { /^\d+$/ ? $_ : "'$_'" } @$args) . ')'
  4 100       25  
384             if $args && ref $args eq 'ARRAY';
385 15         37 push(@output, $name);
386             }
387            
388 11         80 return join('.', @output);
389             }
390              
391              
392             #========================================================================
393             # ----- PRIVATE OBJECT METHODS -----
394             #========================================================================
395              
396             #------------------------------------------------------------------------
397             # _dotop($root, $item, \@args, $lvalue)
398             #
399             # This is the core 'dot' operation method which evaluates elements of
400             # variables against their root. All variables have an implicit root
401             # which is the stash object itself (a hash). Thus, a non-compound
402             # variable 'foo' is actually '(stash.)foo', the compound 'foo.bar' is
403             # '(stash.)foo.bar'. The first parameter is a reference to the current
404             # root, initially the stash itself. The second parameter contains the
405             # name of the variable element, e.g. 'foo'. The third optional
406             # parameter is a reference to a list of any parenthesised arguments
407             # specified for the variable, which are passed to sub-routines, object
408             # methods, etc. The final parameter is an optional flag to indicate
409             # if this variable is being evaluated on the left side of an assignment
410             # (e.g. foo.bar.baz = 10). When set true, intermediated hashes will
411             # be created (e.g. bar) if necessary.
412             #
413             # Returns the result of evaluating the item against the root, having
414             # performed any variable "magic". The value returned can then be used
415             # as the root of the next _dotop() in a compound sequence. Returns
416             # undef if the variable is undefined.
417             #------------------------------------------------------------------------
418              
419             sub _dotop {
420 1001     1001   1571 my ($self, $root, $item, $args, $lvalue) = @_;
421 1001         1635 my $rootref = ref $root;
422 1001   100     5757 my $atroot = (blessed $root && $root->isa(ref $self));
423 1001         1376 my ($value, @result);
424              
425 1001   100     3290 $args ||= [ ];
426 1001   100     11246 $lvalue ||= 0;
427              
428             # print STDERR "_dotop(root=$root, item=$item, args=[@$args])\n"
429             # if $DEBUG;
430              
431             # return undef without an error if either side of the dot is unviable
432 1001 50 33     4882 return undef unless defined($root) and defined($item);
433              
434             # or if an attempt is made to access a private member, starting _ or .
435 1001 50 33     7208 return undef if $PRIVATE && $item =~ /$PRIVATE/;
436              
437 1001 100 100     11197 if ($atroot || $rootref eq 'HASH') {
    100 66        
    100 66        
    100 33        
    50          
    0          
438             # if $root is a regular HASH or a Template::Stash kinda HASH (the
439             # *real* root of everything). We first lookup the named key
440             # in the hash, or create an empty hash in its place if undefined
441             # and the $lvalue flag is set. Otherwise, we check the HASH_OPS
442             # pseudo-methods table, calling the code if found, or return undef.
443            
444 726 100 100     3756 if (defined($value = $root->{ $item })) {
    100 100        
    100          
    100          
445 485 100       2034 return $value unless ref $value eq 'CODE'; ## RETURN
446 17         60 @result = &$value(@$args); ## @result
447             }
448             elsif ($lvalue) {
449             # we create an intermediate hash if this is an lvalue
450 1         16 return $root->{ $item } = { }; ## RETURN
451             }
452             # ugly hack: only allow import vmeth to be called on root stash
453             elsif (($value = $HASH_OPS->{ $item })
454             && ! $atroot || $item eq 'import') {
455 38         165 @result = &$value($root, @$args); ## @result
456             }
457             elsif ( ref $item eq 'ARRAY' ) {
458             # hash slice
459 2         11 return [@$root{@$item}]; ## RETURN
460             }
461             }
462             elsif ($rootref eq 'ARRAY') {
463             # if root is an ARRAY then we check for a LIST_OPS pseudo-method
464             # or return the numerical index into the array, or undef
465 147 100       628 if ($value = $LIST_OPS->{ $item }) {
    100          
    50          
466 138         514 @result = &$value($root, @$args); ## @result
467             }
468             elsif ($item =~ /^-?\d+$/) {
469 8         30 $value = $root->[$item];
470 8 50       66 return $value unless ref $value eq 'CODE'; ## RETURN
471 0         0 @result = &$value(@$args); ## @result
472             }
473             elsif ( ref $item eq 'ARRAY' ) {
474             # array slice
475 1         5 return [@$root[@$item]]; ## RETURN
476             }
477             }
478            
479             # NOTE: we do the can-can because UNIVSERAL::isa($something, 'UNIVERSAL')
480             # doesn't appear to work with CGI, returning true for the first call
481             # and false for all subsequent calls.
482            
483             # UPDATE: that doesn't appear to be the case any more
484            
485             elsif (blessed($root) && $root->can('can')) {
486              
487             # if $root is a blessed reference (i.e. inherits from the
488             # UNIVERSAL object base class) then we call the item as a method.
489             # If that fails then we try to fallback on HASH behaviour if
490             # possible.
491 37         44 eval { @result = $root->$item(@$args); };
  37         237  
492            
493 37 100       214 if ($@) {
494             # temporary hack - required to propagate errors thrown
495             # by views; if $@ is a ref (e.g. Template::Exception
496             # object then we assume it's a real error that needs
497             # real throwing
498              
499 12   33     33 my $class = ref($root) || $root;
500 12 100 66     283 die $@ if ref($@) || ($@ !~ /Can't locate object method "\Q$item\E" via package "\Q$class\E"/);
501              
502             # failed to call object method, so try some fallbacks
503 11 100       56 if (reftype $root eq 'HASH') {
    50          
    0          
    0          
    0          
504 6 100       29 if( defined($value = $root->{ $item })) {
    100          
    50          
505 3 50       15 return $value unless ref $value eq 'CODE'; ## RETURN
506 0         0 @result = &$value(@$args);
507             }
508             elsif ($value = $HASH_OPS->{ $item }) {
509 2         11 @result = &$value($root, @$args);
510             }
511             elsif ($value = $LIST_OPS->{ $item }) {
512 1         7 @result = &$value([$root], @$args);
513             }
514             }
515             elsif (reftype $root eq 'ARRAY') {
516 5 100       25 if( $value = $LIST_OPS->{ $item }) {
    50          
    0          
517 3         18 @result = &$value($root, @$args);
518             }
519             elsif( $item =~ /^-?\d+$/ ) {
520 2         5 $value = $root->[$item];
521 2 50       12 return $value unless ref $value eq 'CODE'; ## RETURN
522 0         0 @result = &$value(@$args); ## @result
523             }
524             elsif ( ref $item eq 'ARRAY' ) {
525             # array slice
526 0         0 return [@$root[@$item]]; ## RETURN
527             }
528             }
529             elsif ($value = $SCALAR_OPS->{ $item }) {
530 0         0 @result = &$value($root, @$args);
531             }
532             elsif ($value = $LIST_OPS->{ $item }) {
533 0         0 @result = &$value([$root], @$args);
534             }
535             elsif ($self->{ _DEBUG }) {
536 0         0 @result = (undef, $@);
537             }
538             }
539             }
540             elsif (($value = $SCALAR_OPS->{ $item }) && ! $lvalue) {
541             # at this point, it doesn't look like we've got a reference to
542             # anything we know about, so we try the SCALAR_OPS pseudo-methods
543             # table (but not for l-values)
544 90         654 @result = &$value($root, @$args); ## @result
545             }
546             elsif (($value = $LIST_OPS->{ $item }) && ! $lvalue) {
547             # last-ditch: can we promote a scalar to a one-element
548             # list and apply a LIST_OPS virtual method?
549 1         7 @result = &$value([$root], @$args);
550             }
551             elsif ($self->{ _DEBUG }) {
552 0         0 die "don't know how to access [ $root ].$item\n"; ## DIE
553             }
554             else {
555 0         0 @result = ();
556             }
557              
558             # fold multiple return items into a list unless first item is undef
559 515 100       2492 if (defined $result[0]) {
    50          
    100          
560             return ## RETURN
561 311 50       3964 scalar @result > 1 ? [ @result ] : $result[0];
562             }
563             elsif (defined $result[1]) {
564 0         0 die $result[1]; ## DIE
565             }
566             elsif ($self->{ _DEBUG }) {
567 2         15 die "$item is undefined\n"; ## DIE
568             }
569              
570 202         651 return undef;
571             }
572              
573              
574             #------------------------------------------------------------------------
575             # _assign($root, $item, \@args, $value, $default)
576             #
577             # Similar to _dotop() above, but assigns a value to the given variable
578             # instead of simply returning it. The first three parameters are the
579             # root item, the item and arguments, as per _dotop(), followed by the
580             # value to which the variable should be set and an optional $default
581             # flag. If set true, the variable will only be set if currently false
582             # (undefined/zero)
583             #------------------------------------------------------------------------
584              
585             sub _assign {
586 491     491   835 my ($self, $root, $item, $args, $value, $default) = @_;
587 491         1052 my $rootref = ref $root;
588 491         1268 my $atroot = ($root eq $self);
589 491         497 my $result;
590 491   50     2341 $args ||= [ ];
591 491   50     1566 $default ||= 0;
592              
593             # return undef without an error if either side of the dot is unviable
594 491 50 33     2049 return undef unless $root and defined $item;
595              
596             # or if an attempt is made to update a private member, starting _ or .
597 491 50 33     3298 return undef if $PRIVATE && $item =~ /$PRIVATE/;
598            
599 491 100 100     2333 if ($rootref eq 'HASH' || $atroot) {
    50 33        
    0          
600             # if the root is a hash we set the named key
601 490 50 33     10375 return ($root->{ $item } = $value) ## RETURN
602             unless $default && $root->{ $item };
603             }
604             elsif ($rootref eq 'ARRAY' && $item =~ /^-?\d+$/) {
605             # or set a list item by index number
606 1 50 33     12 return ($root->[$item] = $value) ## RETURN
607             unless $default && $root->{ $item };
608             }
609             elsif (blessed($root)) {
610             # try to call the item as a method of an object
611            
612 0 0 0       return $root->$item(@$args, $value) ## RETURN
613             unless $default && $root->$item();
614            
615             # 2 issues:
616             # - method call should be wrapped in eval { }
617             # - fallback on hash methods if object method not found
618             #
619             # eval { $result = $root->$item(@$args, $value); };
620             #
621             # if ($@) {
622             # die $@ if ref($@) || ($@ !~ /Can't locate object method/);
623             #
624             # # failed to call object method, so try some fallbacks
625             # if (UNIVERSAL::isa($root, 'HASH') && exists $root->{ $item }) {
626             # $result = ($root->{ $item } = $value)
627             # unless $default && $root->{ $item };
628             # }
629             # }
630             # return $result; ## RETURN
631             }
632             else {
633 0           die "don't know how to assign to [$root].[$item]\n"; ## DIE
634             }
635              
636 0           return undef;
637             }
638              
639              
640             #------------------------------------------------------------------------
641             # _dump()
642             #
643             # Debug method which returns a string representing the internal state
644             # of the object. The method calls itself recursively to dump sub-hashes.
645             #------------------------------------------------------------------------
646              
647             sub _dump {
648 0     0     my $self = shift;
649 0           return "[Template::Stash] " . $self->_dump_frame(2);
650             }
651              
652             sub _dump_frame {
653 0     0     my ($self, $indent) = @_;
654 0   0       $indent ||= 1;
655 0           my $buffer = ' ';
656 0           my $pad = $buffer x $indent;
657 0           my $text = "{\n";
658 0           local $" = ', ';
659              
660 0           my ($key, $value);
661              
662 0 0         return $text . "...excessive recursion, terminating\n"
663             if $indent > 32;
664            
665 0           foreach $key (keys %$self) {
666 0           $value = $self->{ $key };
667 0 0         $value = '' unless defined $value;
668 0 0         next if $key =~ /^\./;
669 0 0         if (ref($value) eq 'ARRAY') {
    0          
670 0 0         $value = '[ ' . join(', ', map { defined $_ ? $_ : '' }
  0            
671             @$value) . ' ]';
672             }
673             elsif (ref $value eq 'HASH') {
674 0           $value = _dump_frame($value, $indent + 1);
675             }
676            
677 0           $text .= sprintf("$pad%-16s => $value\n", $key);
678             }
679 0           $text .= $buffer x ($indent - 1) . '}';
680 0           return $text;
681             }
682              
683              
684             1;
685              
686             __END__