← Index
NYTProf Performance Profile   « line view »
For starman worker -M FindBin --max-requests 50 --workers 2 --user=kohadev-koha --group kohadev-koha --pid /var/run/koha/kohadev/plack.pid --daemonize --access-log /var/log/koha/kohadev/plack.log --error-log /var/log/koha/kohadev/plack-error.log -E deployment --socket /var/run/koha/kohadev/plack.sock /etc/koha/sites/kohadev/plack.psgi
  Run on Fri Jan 8 14:31:06 2016
Reported on Fri Jan 8 14:33:30 2016

Filename/usr/lib/x86_64-linux-gnu/perl5/5.20/Template/Plugins.pm
StatementsExecuted 189 statements in 375µs
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
16114.75ms7.09msTemplate::Plugins::::_loadTemplate::Plugins::_load
2511425µs7.64msTemplate::Plugins::::fetchTemplate::Plugins::fetch
411171µs171µsTemplate::Plugins::::_initTemplate::Plugins::_init
362177µs77µsTemplate::Plugins::::CORE:substTemplate::Plugins::CORE:subst (opcode)
41127µs27µsTemplate::Plugins::::CORE:regcompTemplate::Plugins::CORE:regcomp (opcode)
11118µs28µsTemplate::Plugins::::BEGIN@26Template::Plugins::BEGIN@26
41113µs13µsTemplate::Plugins::::CORE:matchTemplate::Plugins::CORE:match (opcode)
11110µs18µsTemplate::Plugins::::BEGIN@27Template::Plugins::BEGIN@27
1119µs56µsTemplate::Plugins::::BEGIN@28Template::Plugins::BEGIN@28
1119µs28µsTemplate::Plugins::::BEGIN@29Template::Plugins::BEGIN@29
0000s0sTemplate::Plugins::::__ANON__[:238]Template::Plugins::__ANON__[:238]
0000s0sTemplate::Plugins::::_dumpTemplate::Plugins::_dump
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1#============================================================= -*-Perl-*-
2#
3# Template::Plugins
4#
5# DESCRIPTION
6# Plugin provider which handles the loading of plugin modules and
7# instantiation of plugin objects.
8#
9# AUTHORS
10# Andy Wardley <abw@wardley.org>
11#
12# COPYRIGHT
13# Copyright (C) 1996-2006 Andy Wardley. All Rights Reserved.
14# Copyright (C) 1998-2000 Canon Research Centre Europe Ltd.
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# REVISION
20# $Id$
21#
22#============================================================================
23
24package Template::Plugins;
25
26239µs
# spent 28µs (18+11) within Template::Plugins::BEGIN@26 which was called: # once (18µs+11µs) by Template::Config::load at line 26
use strict;
# spent 28µs making 1 call to Template::Plugins::BEGIN@26 # spent 11µs making 1 call to strict::import
27227µs
# spent 18µs (10+8) within Template::Plugins::BEGIN@27 which was called: # once (10µs+8µs) by Template::Config::load at line 27
use warnings;
# spent 18µs making 1 call to Template::Plugins::BEGIN@27 # spent 8µs making 1 call to warnings::import
282104µs
# spent 56µs (9+47) within Template::Plugins::BEGIN@28 which was called: # once (9µs+47µs) by Template::Config::load at line 28
use base 'Template::Base';
# spent 56µs making 1 call to Template::Plugins::BEGIN@28 # spent 47µs making 1 call to base::import
29247µs
# spent 28µs (9+19) within Template::Plugins::BEGIN@29 which was called: # once (9µs+19µs) by Template::Config::load at line 29
use Template::Constants;
# spent 28µs making 1 call to Template::Plugins::BEGIN@29 # spent 19µs making 1 call to Exporter::import
30
31our $VERSION = 2.77;
32our $DEBUG = 0 unless defined $DEBUG;
33our $PLUGIN_BASE = 'Template::Plugin';
34our $STD_PLUGINS = {
35 'assert' => 'Template::Plugin::Assert',
36 'cgi' => 'Template::Plugin::CGI',
37 'datafile' => 'Template::Plugin::Datafile',
38 'date' => 'Template::Plugin::Date',
39 'debug' => 'Template::Plugin::Debug',
40 'directory' => 'Template::Plugin::Directory',
41 'dbi' => 'Template::Plugin::DBI',
42 'dumper' => 'Template::Plugin::Dumper',
43 'file' => 'Template::Plugin::File',
44 'format' => 'Template::Plugin::Format',
45 'html' => 'Template::Plugin::HTML',
46 'image' => 'Template::Plugin::Image',
47 'iterator' => 'Template::Plugin::Iterator',
48 'latex' => 'Template::Plugin::Latex',
49 'pod' => 'Template::Plugin::Pod',
50 'scalar' => 'Template::Plugin::Scalar',
51 'table' => 'Template::Plugin::Table',
52 'url' => 'Template::Plugin::URL',
53 'view' => 'Template::Plugin::View',
54 'wrap' => 'Template::Plugin::Wrap',
55 'xml' => 'Template::Plugin::XML',
56 'xmlstyle' => 'Template::Plugin::XML::Style',
57};
58
59
60#========================================================================
61# -- PUBLIC METHODS --
62#========================================================================
63
64#------------------------------------------------------------------------
65# fetch($name, \@args, $context)
66#
67# General purpose method for requesting instantiation of a plugin
68# object. The name of the plugin is passed as the first parameter.
69# The internal FACTORY lookup table is consulted to retrieve the
70# appropriate factory object or class name. If undefined, the _load()
71# method is called to attempt to load the module and return a factory
72# class/object which is then cached for subsequent use. A reference
73# to the calling context should be passed as the third parameter.
74# This is passed to the _load() class method. The new() method is
75# then called against the factory class name or prototype object to
76# instantiate a new plugin object, passing any arguments specified by
77# list reference as the second parameter. e.g. where $factory is the
78# class name 'MyClass', the new() method is called as a class method,
79# $factory->new(...), equivalent to MyClass->new(...) . Where
80# $factory is a prototype object, the new() method is called as an
81# object method, $myobject->new(...). This latter approach allows
82# plugins to act as Singletons, cache shared data, etc.
83#
84# Returns a reference to a plugin, (undef, STATUS_DECLINE) to decline
85# the request or ($error, STATUS_ERROR) on error.
86#------------------------------------------------------------------------
87
88
# spent 7.64ms (425µs+7.22) within Template::Plugins::fetch which was called 25 times, avg 306µs/call: # 25 times (425µs+7.22ms) by Template::Context::plugin at line 192 of Template/Context.pm, avg 306µs/call
sub fetch {
8974µs my ($self, $name, $args, $context) = @_;
9072µs my ($factory, $plugin, $error);
91
92 $self->debug("fetch($name, ",
93 defined $args ? ('[ ', join(', ', @$args), ' ]') : '<no args>', ', ',
94 defined $context ? $context : '<no context>',
9576µs ')') if $self->{ DEBUG };
96
97 # NOTE:
98 # the $context ref gets passed as the first parameter to all regular
99 # plugins, but not to those loaded via LOAD_PERL; to hack around
100 # this until we have a better implementation, we pass the $args
101 # reference to _load() and let it unshift the first args in the
102 # LOAD_PERL case
103
10474µs $args ||= [ ];
10574µs unshift @$args, $context;
106
107713µs $factory = $self->{ FACTORY }->{ $name } ||= do {
108411µs167.09ms ($factory, $error) = $self->_load($name, $context);
# spent 7.09ms making 16 calls to Template::Plugins::_load, avg 443µs/call
1094800ns return ($factory, $error) if $error; ## RETURN
11041µs $factory;
111 };
112
113 # call the new() method on the factory object or class name
11473µs eval {
11576µs if (ref $factory eq 'CODE') {
116 defined( $plugin = &$factory(@$args) )
117 || die "$name plugin failed\n";
118 }
119 else {
120735µs25130µs defined( $plugin = $factory->new(@$args) )
# spent 75µs making 21 calls to Template::Plugin::new, avg 4µs/call # spent 56µs making 4 calls to Template::Plugin::String::new, avg 14µs/call
121 || die "$name plugin failed: ", $factory->error(), "\n";
122 }
123 };
12474µs if ($error = $@) {
125# chomp $error;
126 return $self->{ TOLERANT }
127 ? (undef, Template::Constants::STATUS_DECLINED)
128 : ($error, Template::Constants::STATUS_ERROR);
129 }
130
131721µs return $plugin;
132}
133
- -
136#========================================================================
137# -- PRIVATE METHODS --
138#========================================================================
139
140#------------------------------------------------------------------------
141# _init(\%config)
142#
143# Private initialisation method.
144#------------------------------------------------------------------------
145
146
# spent 171µs within Template::Plugins::_init which was called 4 times, avg 43µs/call: # 4 times (171µs+0s) by Template::Base::new at line 65 of Template/Base.pm, avg 43µs/call
sub _init {
1471400ns my ($self, $params) = @_;
14812µs my ($pbase, $plugins, $factory) =
149 @$params{ qw( PLUGIN_BASE PLUGINS PLUGIN_FACTORY ) };
150
1511500ns $plugins ||= { };
152
153 # update PLUGIN_BASE to an array ref if necessary
1541400ns $pbase = [ ] unless defined $pbase;
15511µs $pbase = [ $pbase ] unless ref($pbase) eq 'ARRAY';
156
157 # add default plugin base (Template::Plugin) if set
15811µs push(@$pbase, $PLUGIN_BASE) if $PLUGIN_BASE;
159
1601500ns $self->{ PLUGIN_BASE } = $pbase;
161135µs $self->{ PLUGINS } = { %$STD_PLUGINS, %$plugins };
1621700ns $self->{ TOLERANT } = $params->{ TOLERANT } || 0;
16312µs $self->{ LOAD_PERL } = $params->{ LOAD_PERL } || 0;
1641700ns $self->{ FACTORY } = $factory || { };
16511µs $self->{ DEBUG } = ( $params->{ DEBUG } || 0 )
166 & Template::Constants::DEBUG_PLUGINS;
167
16814µs return $self;
169}
170
- -
173#------------------------------------------------------------------------
174# _load($name, $context)
175#
176# Private method which attempts to load a plugin module and determine the
177# correct factory name or object by calling the load() class method in
178# the loaded module.
179#------------------------------------------------------------------------
180
181
# spent 7.09ms (4.75+2.34) within Template::Plugins::_load which was called 16 times, avg 443µs/call: # 16 times (4.75ms+2.34ms) by Template::Plugins::fetch at line 108, avg 443µs/call
sub _load {
18242µs my ($self, $name, $context) = @_;
18342µs my ($factory, $module, $base, $pkg, $file, $ok, $error);
184
185410µs if ($module = $self->{ PLUGINS }->{ $name } || $self->{ PLUGINS }->{ lc $name }) {
186 # plugin module name is explicitly stated in PLUGIN_NAME
187 $pkg = $module;
188 ($file = $module) =~ s|::|/|g;
189 $file =~ s|::|/|g;
190 $self->debug("loading $module.pm (PLUGIN_NAME)")
191 if $self->{ DEBUG };
192 $ok = eval { require "$file.pm" };
193 $error = $@;
194 }
195 else {
196 # try each of the PLUGIN_BASE values to build module name
197418µs1628µs ($module = $name) =~ s/\./::/g;
# spent 28µs making 16 calls to Template::Plugins::CORE:subst, avg 2µs/call
198
19946µs foreach $base (@{ $self->{ PLUGIN_BASE } }) {
20056µs $pkg = $base . '::' . $module;
201523µs2049µs ($file = $pkg) =~ s|::|/|g;
# spent 49µs making 20 calls to Template::Plugins::CORE:subst, avg 2µs/call
202
203 $self->debug("loading $file.pm (PLUGIN_BASE)")
20452µs if $self->{ DEBUG };
205
2061069µs $ok = eval { require "$file.pm" };
20755µs last unless $@;
208
209113µs840µs $error .= "$@\n"
# spent 27µs making 4 calls to Template::Plugins::CORE:regcomp, avg 7µs/call # spent 13µs making 4 calls to Template::Plugins::CORE:match, avg 3µs/call
210 unless ($@ =~ /^Can\'t locate $file\.pm/);
211 }
212 }
213
21442µs if ($ok) {
21541µs $self->debug("calling $pkg->load()") if $self->{ DEBUG };
216
217836µs1641µs $factory = eval { $pkg->load($context) };
# spent 41µs making 16 calls to Template::Plugin::load, avg 3µs/call
21841µs $error = '';
21943µs if ($@ || ! $factory) {
220 $error = $@ || 'load() returned a false value';
221 }
222 }
223 elsif ($self->{ LOAD_PERL }) {
224 # fallback - is it a regular Perl module?
225 ($file = $module) =~ s|::|/|g;
226 eval { require "$file.pm" };
227 if ($@) {
228 $error = $@;
229 }
230 else {
231 # this is a regular Perl module so the new() constructor
232 # isn't expecting a $context reference as the first argument;
233 # so we construct a closure which removes it before calling
234 # $module->new(@_);
235 $factory = sub {
236 shift;
237 $module->new(@_);
238 };
239 $error = '';
240 }
241 }
242
24341µs if ($factory) {
24441µs $self->debug("$name => $factory") if $self->{ DEBUG };
245410µs return $factory;
246 }
247 elsif ($error) {
248 return $self->{ TOLERANT }
249 ? (undef, Template::Constants::STATUS_DECLINED)
250 : ($error, Template::Constants::STATUS_ERROR);
251 }
252 else {
253 return (undef, Template::Constants::STATUS_DECLINED);
254 }
255}
256
257
258#------------------------------------------------------------------------
259# _dump()
260#
261# Debug method which constructs and returns text representing the current
262# state of the object.
263#------------------------------------------------------------------------
264
265sub _dump {
266 my $self = shift;
267 my $output = "[Template::Plugins] {\n";
268 my $format = " %-16s => %s\n";
269 my $key;
270
271 foreach $key (qw( TOLERANT LOAD_PERL )) {
272 $output .= sprintf($format, $key, $self->{ $key });
273 }
274
275 local $" = ', ';
276 my $fkeys = join(", ", keys %{$self->{ FACTORY }});
277 my $plugins = $self->{ PLUGINS };
278 $plugins = join('', map {
279 sprintf(" $format", $_, $plugins->{ $_ });
280 } keys %$plugins);
281 $plugins = "{\n$plugins }";
282
283 $output .= sprintf($format, 'PLUGIN_BASE', "[ @{ $self->{ PLUGIN_BASE } } ]");
284 $output .= sprintf($format, 'PLUGINS', $plugins);
285 $output .= sprintf($format, 'FACTORY', $fkeys);
286 $output .= '}';
287 return $output;
288}
289
290
2911;
292
293__END__
 
# spent 13µs within Template::Plugins::CORE:match which was called 4 times, avg 3µs/call: # 4 times (13µs+0s) by Template::Plugins::_load at line 209, avg 3µs/call
sub Template::Plugins::CORE:match; # opcode
# spent 27µs within Template::Plugins::CORE:regcomp which was called 4 times, avg 7µs/call: # 4 times (27µs+0s) by Template::Plugins::_load at line 209, avg 7µs/call
sub Template::Plugins::CORE:regcomp; # opcode
# spent 77µs within Template::Plugins::CORE:subst which was called 36 times, avg 2µs/call: # 20 times (49µs+0s) by Template::Plugins::_load at line 201, avg 2µs/call # 16 times (28µs+0s) by Template::Plugins::_load at line 197, avg 2µs/call
sub Template::Plugins::CORE:subst; # opcode
Report produced by the NYTProf 6.02 Perl profiler, developed by Tim Bunce and Adam Kaplan.