Filename | /usr/lib/x86_64-linux-gnu/perl5/5.28/Template/Service.pm |
Statements | Executed 19520144 statements in 33.3s |
Calls | P | F | Exclusive Time |
Inclusive Time |
Subroutine |
---|---|---|---|---|---|
375387 | 1 | 1 | 29.2s | 1623s | process (recurses: max depth 40, inclusive time 29391s) | Template::Service::
375387 | 1 | 1 | 9.21s | 122s | _init | Template::Service::
1 | 1 | 1 | 500µs | 680µs | BEGIN@27 | Template::Service::
1 | 1 | 1 | 16µs | 17µs | BEGIN@26 | Template::Service::
1 | 1 | 1 | 14µs | 17µs | BEGIN@23 | Template::Service::
1 | 1 | 1 | 8µs | 34µs | BEGIN@29 | Template::Service::
1 | 1 | 1 | 7µs | 33µs | BEGIN@28 | Template::Service::
1 | 1 | 1 | 7µs | 34µs | BEGIN@24 | Template::Service::
1 | 1 | 1 | 7µs | 128µs | BEGIN@25 | Template::Service::
1 | 1 | 1 | 6µs | 32µs | BEGIN@31 | Template::Service::
2 | 2 | 1 | 2µs | 2µs | __ANON__ (xsub) | Template::Service::
0 | 0 | 0 | 0s | 0s | _dump | Template::Service::
0 | 0 | 0 | 0s | 0s | _recover | Template::Service::
0 | 0 | 0 | 0s | 0s | context | Template::Service::
Line | State ments |
Time on line |
Calls | Time in subs |
Code |
---|---|---|---|---|---|
1 | #============================================================= -*-Perl-*- | ||||
2 | # | ||||
3 | # Template::Service | ||||
4 | # | ||||
5 | # DESCRIPTION | ||||
6 | # Module implementing a template processing service which wraps a | ||||
7 | # template within PRE_PROCESS and POST_PROCESS templates and offers | ||||
8 | # ERROR recovery. | ||||
9 | # | ||||
10 | # AUTHOR | ||||
11 | # Andy Wardley <abw@wardley.org> | ||||
12 | # | ||||
13 | # COPYRIGHT | ||||
14 | # Copyright (C) 1996-2007 Andy Wardley. All Rights Reserved. | ||||
15 | # | ||||
16 | # This module is free software; you can redistribute it and/or | ||||
17 | # modify it under the same terms as Perl itself. | ||||
18 | # | ||||
19 | #============================================================================ | ||||
20 | |||||
21 | package Template::Service; | ||||
22 | |||||
23 | 2 | 22µs | 2 | 20µs | # spent 17µs (14+3) within Template::Service::BEGIN@23 which was called:
# once (14µs+3µs) by Template::BEGIN@30 at line 23 # spent 17µs making 1 call to Template::Service::BEGIN@23
# spent 3µs making 1 call to strict::import |
24 | 2 | 23µs | 2 | 62µs | # spent 34µs (7+27) within Template::Service::BEGIN@24 which was called:
# once (7µs+27µs) by Template::BEGIN@30 at line 24 # spent 34µs making 1 call to Template::Service::BEGIN@24
# spent 27µs making 1 call to warnings::import |
25 | 2 | 25µs | 2 | 249µs | # spent 128µs (7+121) within Template::Service::BEGIN@25 which was called:
# once (7µs+121µs) by Template::BEGIN@30 at line 25 # spent 128µs making 1 call to Template::Service::BEGIN@25
# spent 121µs making 1 call to base::import |
26 | 2 | 32µs | 2 | 17µs | # spent 17µs (16+500ns) within Template::Service::BEGIN@26 which was called:
# once (16µs+500ns) by Template::BEGIN@30 at line 26 # spent 17µs making 1 call to Template::Service::BEGIN@26
# spent 500ns making 1 call to Template::Service::__ANON__ |
27 | 2 | 107µs | 2 | 681µs | # spent 680µs (500+180) within Template::Service::BEGIN@27 which was called:
# once (500µs+180µs) by Template::BEGIN@30 at line 27 # spent 680µs making 1 call to Template::Service::BEGIN@27
# spent 1µs making 1 call to Template::Service::__ANON__ |
28 | 2 | 24µs | 2 | 59µs | # spent 33µs (7+26) within Template::Service::BEGIN@28 which was called:
# once (7µs+26µs) by Template::BEGIN@30 at line 28 # spent 33µs making 1 call to Template::Service::BEGIN@28
# spent 26µs making 1 call to Exporter::import |
29 | 2 | 52µs | 2 | 60µs | # spent 34µs (8+26) within Template::Service::BEGIN@29 which was called:
# once (8µs+26µs) by Template::BEGIN@30 at line 29 # spent 34µs making 1 call to Template::Service::BEGIN@29
# spent 26µs making 1 call to Exporter::import |
30 | |||||
31 | 2 | 996µs | 2 | 59µs | # spent 32µs (6+27) within Template::Service::BEGIN@31 which was called:
# once (6µs+27µs) by Template::BEGIN@30 at line 31 # spent 32µs making 1 call to Template::Service::BEGIN@31
# spent 27µs making 1 call to constant::import |
32 | |||||
33 | 1 | 400ns | our $VERSION = 2.80; | ||
34 | 1 | 300ns | our $DEBUG = 0 unless defined $DEBUG; | ||
35 | 1 | 200ns | our $ERROR = ''; | ||
36 | |||||
37 | |||||
38 | #======================================================================== | ||||
39 | # ----- PUBLIC METHODS ----- | ||||
40 | #======================================================================== | ||||
41 | |||||
42 | #------------------------------------------------------------------------ | ||||
43 | # process($template, \%params) | ||||
44 | # | ||||
45 | # Process a template within a service framework. A service may encompass | ||||
46 | # PRE_PROCESS and POST_PROCESS templates and an ERROR hash which names | ||||
47 | # templates to be substituted for the main template document in case of | ||||
48 | # error. Each service invocation begins by resetting the state of the | ||||
49 | # context object via a call to reset(). The AUTO_RESET option may be set | ||||
50 | # to 0 (default: 1) to bypass this step. | ||||
51 | #------------------------------------------------------------------------ | ||||
52 | |||||
53 | # spent 1623s (29.2+1593) within Template::Service::process which was called 375387 times, avg 4.32ms/call:
# 375387 times (29.2s+1593s) by Template::process at line 66 of Template.pm, avg 4.32ms/call | ||||
54 | 375387 | 253ms | my ($self, $template, $params) = @_; | ||
55 | 375387 | 338ms | my $context = $self->{ CONTEXT }; | ||
56 | 375387 | 143ms | my ($name, $output, $procout, $error); | ||
57 | 375387 | 224ms | $output = ''; | ||
58 | |||||
59 | $self->debug("process($template, ", | ||||
60 | defined $params ? $params : '<no params>', | ||||
61 | 375387 | 212ms | ')') if $self->{ DEBUG }; | ||
62 | |||||
63 | $context->reset() | ||||
64 | 375387 | 1.26s | 375387 | 1.73s | if $self->{ AUTO_RESET }; # spent 1.73s making 375387 calls to Template::Context::reset, avg 5µs/call |
65 | |||||
66 | # pre-request compiled template from context so that we can alias it | ||||
67 | # in the stash for pre-processed templates to reference | ||||
68 | 750774 | 1.04s | 375387 | 397s | eval { $template = $context->template($template) }; # spent 397s making 375387 calls to Template::Context::template, avg 1.06ms/call |
69 | 375387 | 154ms | return $self->error($@) | ||
70 | if $@; | ||||
71 | |||||
72 | # localise the variable stash with any parameters passed | ||||
73 | # and set the 'template' variable | ||||
74 | 375387 | 165ms | $params ||= { }; | ||
75 | # TODO: change this to C<||=> so we can use a template parameter | ||||
76 | 375387 | 786ms | $params->{ template } = $template | ||
77 | unless ref $template eq 'CODE'; | ||||
78 | 375387 | 1.38s | 375387 | 10.6s | $context->localise($params); # spent 10.6s making 375387 calls to Template::Context::localise, avg 28µs/call |
79 | |||||
80 | SERVICE: { | ||||
81 | # PRE_PROCESS | ||||
82 | 750774 | 359ms | eval { | ||
83 | 375387 | 562ms | foreach $name (@{ $self->{ PRE_PROCESS } }) { | ||
84 | $self->debug("PRE_PROCESS: $name") if $self->{ DEBUG }; | ||||
85 | $output .= $context->process($name); | ||||
86 | } | ||||
87 | }; | ||||
88 | 375387 | 245ms | last SERVICE if ($error = $@); | ||
89 | |||||
90 | # PROCESS | ||||
91 | 375387 | 141ms | eval { | ||
92 | 375387 | 674ms | foreach $name (@{ $self->{ PROCESS } || [ $template ] }) { | ||
93 | 375387 | 252ms | $self->debug("PROCESS: $name") if $self->{ DEBUG }; | ||
94 | 375387 | 1.50s | 375387 | 1622s | $procout .= $context->process($name); # spent 30564s making 375387 calls to Template::Context::process, avg 81.4ms/call, recursion: max depth 41, sum of overlapping time 28942s |
95 | } | ||||
96 | }; | ||||
97 | 375387 | 165ms | if ($error = $@) { | ||
98 | last SERVICE | ||||
99 | unless defined ($procout = $self->_recover(\$error)); | ||||
100 | } | ||||
101 | |||||
102 | 375387 | 241ms | if (defined $procout) { | ||
103 | # WRAPPER | ||||
104 | 375387 | 111ms | eval { | ||
105 | 375387 | 511ms | foreach $name (reverse @{ $self->{ WRAPPER } }) { | ||
106 | $self->debug("WRAPPER: $name") if $self->{ DEBUG }; | ||||
107 | $procout = $context->process($name, { content => $procout }); | ||||
108 | } | ||||
109 | }; | ||||
110 | 375387 | 114ms | last SERVICE if ($error = $@); | ||
111 | 375387 | 175ms | $output .= $procout; | ||
112 | } | ||||
113 | |||||
114 | # POST_PROCESS | ||||
115 | 375387 | 128ms | eval { | ||
116 | 375387 | 458ms | foreach $name (@{ $self->{ POST_PROCESS } }) { | ||
117 | $self->debug("POST_PROCESS: $name") if $self->{ DEBUG }; | ||||
118 | $output .= $context->process($name); | ||||
119 | } | ||||
120 | }; | ||||
121 | 375387 | 125ms | last SERVICE if ($error = $@); | ||
122 | } | ||||
123 | |||||
124 | 375387 | 630ms | 375387 | 6.54s | $context->delocalise(); # spent 6.54s making 375387 calls to Template::Context::delocalise, avg 17µs/call |
125 | 375387 | 263ms | delete $params->{ template }; | ||
126 | |||||
127 | 375387 | 126ms | if ($error) { | ||
128 | # $error = $error->as_string if ref $error; | ||||
129 | return $self->error($error); | ||||
130 | } | ||||
131 | |||||
132 | 375387 | 11.2s | 375387 | 4.03s | return $output; # spent 4.03s making 375387 calls to Template::Document::AUTOLOAD, avg 11µs/call |
133 | } | ||||
134 | |||||
135 | |||||
136 | #------------------------------------------------------------------------ | ||||
137 | # context() | ||||
138 | # | ||||
139 | # Returns the internal CONTEXT reference. | ||||
140 | #------------------------------------------------------------------------ | ||||
141 | |||||
142 | sub context { | ||||
143 | return $_[0]->{ CONTEXT }; | ||||
144 | } | ||||
145 | |||||
146 | |||||
147 | #======================================================================== | ||||
148 | # -- PRIVATE METHODS -- | ||||
149 | #======================================================================== | ||||
150 | |||||
151 | # spent 122s (9.21+112) within Template::Service::_init which was called 375387 times, avg 324µs/call:
# 375387 times (9.21s+112s) by Template::Base::new at line 65 of Template/Base.pm, avg 324µs/call | ||||
152 | 375387 | 207ms | my ($self, $config) = @_; | ||
153 | 375387 | 131ms | my ($item, $data, $context, $block, $blocks); | ||
154 | 375387 | 336ms | my $delim = $config->{ DELIMITER }; | ||
155 | 375387 | 459ms | $delim = ':' unless defined $delim; | ||
156 | |||||
157 | # coerce PRE_PROCESS, PROCESS and POST_PROCESS to arrays if necessary, | ||||
158 | # by splitting on non-word characters | ||||
159 | 375387 | 789ms | foreach $item (qw( PRE_PROCESS PROCESS POST_PROCESS WRAPPER )) { | ||
160 | 1501548 | 555ms | $data = $config->{ $item }; | ||
161 | 1501548 | 1.63s | $self->{ $item } = [ ], next unless (defined $data); | ||
162 | $data = [ split($delim, $data || '') ] | ||||
163 | unless ref $data eq 'ARRAY'; | ||||
164 | $self->{ $item } = $data; | ||||
165 | } | ||||
166 | # unset PROCESS option unless explicitly specified in config | ||||
167 | $self->{ PROCESS } = undef | ||||
168 | 375387 | 525ms | unless defined $config->{ PROCESS }; | ||
169 | |||||
170 | 375387 | 581ms | $self->{ ERROR } = $config->{ ERROR } || $config->{ ERRORS }; | ||
171 | $self->{ AUTO_RESET } = defined $config->{ AUTO_RESET } | ||||
172 | 375387 | 774ms | ? $config->{ AUTO_RESET } : 1; | ||
173 | 375387 | 457ms | $self->{ DEBUG } = ( $config->{ DEBUG } || 0 ) | ||
174 | & Template::Constants::DEBUG_SERVICE; | ||||
175 | |||||
176 | $context = $self->{ CONTEXT } = $config->{ CONTEXT } | ||||
177 | 375387 | 1.17s | 375387 | 112s | || Template::Config->context($config) # spent 112s making 375387 calls to Template::Config::context, avg 299µs/call |
178 | || return $self->error(Template::Config->error); | ||||
179 | |||||
180 | 375387 | 1.76s | return $self; | ||
181 | } | ||||
182 | |||||
183 | |||||
184 | #------------------------------------------------------------------------ | ||||
185 | # _recover(\$exception) | ||||
186 | # | ||||
187 | # Examines the internal ERROR hash array to find a handler suitable | ||||
188 | # for the exception object passed by reference. Selecting the handler | ||||
189 | # is done by delegation to the exception's select_handler() method, | ||||
190 | # passing the set of handler keys as arguments. A 'default' handler | ||||
191 | # may also be provided. The handler value represents the name of a | ||||
192 | # template which should be processed. | ||||
193 | #------------------------------------------------------------------------ | ||||
194 | |||||
195 | sub _recover { | ||||
196 | my ($self, $error) = @_; | ||||
197 | my $context = $self->{ CONTEXT }; | ||||
198 | my ($hkey, $handler, $output); | ||||
199 | |||||
200 | # there shouldn't ever be a non-exception object received at this | ||||
201 | # point... unless a module like CGI::Carp messes around with the | ||||
202 | # DIE handler. | ||||
203 | return undef | ||||
204 | unless blessed($$error) && $$error->isa(EXCEPTION); | ||||
205 | |||||
206 | # a 'stop' exception is thrown by [% STOP %] - we return the output | ||||
207 | # buffer stored in the exception object | ||||
208 | return $$error->text() | ||||
209 | if $$error->type() eq 'stop'; | ||||
210 | |||||
211 | my $handlers = $self->{ ERROR } | ||||
212 | || return undef; ## RETURN | ||||
213 | |||||
214 | if (ref $handlers eq 'HASH') { | ||||
215 | if ($hkey = $$error->select_handler(keys %$handlers)) { | ||||
216 | $handler = $handlers->{ $hkey }; | ||||
217 | $self->debug("using error handler for $hkey") if $self->{ DEBUG }; | ||||
218 | } | ||||
219 | elsif ($handler = $handlers->{ default }) { | ||||
220 | # use default handler | ||||
221 | $self->debug("using default error handler") if $self->{ DEBUG }; | ||||
222 | } | ||||
223 | else { | ||||
224 | return undef; ## RETURN | ||||
225 | } | ||||
226 | } | ||||
227 | else { | ||||
228 | $handler = $handlers; | ||||
229 | $self->debug("using default error handler") if $self->{ DEBUG }; | ||||
230 | } | ||||
231 | |||||
232 | eval { $handler = $context->template($handler) }; | ||||
233 | if ($@) { | ||||
234 | $$error = $@; | ||||
235 | return undef; ## RETURN | ||||
236 | }; | ||||
237 | |||||
238 | $context->stash->set('error', $$error); | ||||
239 | eval { | ||||
240 | $output .= $context->process($handler); | ||||
241 | }; | ||||
242 | if ($@) { | ||||
243 | $$error = $@; | ||||
244 | return undef; ## RETURN | ||||
245 | } | ||||
246 | |||||
247 | return $output; | ||||
248 | } | ||||
249 | |||||
- - | |||||
252 | #------------------------------------------------------------------------ | ||||
253 | # _dump() | ||||
254 | # | ||||
255 | # Debug method which return a string representing the internal object | ||||
256 | # state. | ||||
257 | #------------------------------------------------------------------------ | ||||
258 | |||||
259 | sub _dump { | ||||
260 | my $self = shift; | ||||
261 | my $context = $self->{ CONTEXT }->_dump(); | ||||
262 | $context =~ s/\n/\n /gm; | ||||
263 | |||||
264 | my $error = $self->{ ERROR }; | ||||
265 | $error = join('', | ||||
266 | "{\n", | ||||
267 | (map { " $_ => $error->{ $_ }\n" } | ||||
268 | keys %$error), | ||||
269 | "}\n") | ||||
270 | if ref $error; | ||||
271 | |||||
272 | local $" = ', '; | ||||
273 | return <<EOF; | ||||
274 | $self | ||||
275 | PRE_PROCESS => [ @{ $self->{ PRE_PROCESS } } ] | ||||
276 | POST_PROCESS => [ @{ $self->{ POST_PROCESS } } ] | ||||
277 | ERROR => $error | ||||
278 | CONTEXT => $context | ||||
279 | EOF | ||||
280 | } | ||||
281 | |||||
282 | |||||
283 | 1 | 4µs | 1; | ||
284 | |||||
285 | __END__ | ||||
sub Template::Service::__ANON__; # xsub |