lib/Dancer2/Core/App.pm

filter: Statementstmt 97.2% 820 / 843 Branchbran 87.6% 263 / 300 Conditioncond 63.1% 113 / 179 MC/DCmcdc 33.3% 35 / 105 Subroutinesub 96.3% 130 / 135 Podpod 40.0% 18 / 45 totaltotal 85.8% 1379 / 1607 CC 237 SCAR 20.5
CC
237
Cov
90%
send_file
34.3
send_as
18.0
dispatch
13.0
CRAP 7.8
« blib/lib/Dancer2/Handler/File.pm ↑ Summary lib/Dancer2/ConfigReader/Config/Any.pm »
1 # ABSTRACT: encapsulation of Dancer2 packages
2 package Dancer2::Core::App;
3 183 $Dancer2::Core::App::VERSION = '2.3.0';
4 183 ▶use Moo;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 183 ▶use Carp qw<croak carp>;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 183 ▶use Scalar::Util 'blessed';
Subroutine BEGIN: called CC=1 SCAR=0.0
7 183 ▶use List::Util ();
Subroutine BEGIN: called CC=1 SCAR=0.0
8 183 ▶use Module::Runtime 'is_module_name';
Subroutine BEGIN: called CC=1 SCAR=0.0
9 183 ▶use Safe::Isa;
Subroutine BEGIN: called CC=1 SCAR=0.0
10 183 ▶use Sub::Quote;
Subroutine BEGIN: called CC=1 SCAR=0.0
11 183 ▶use Path::Tiny ();
Subroutine BEGIN: called CC=1 SCAR=0.0
12 183 ▶use Module::Runtime qw< require_module use_module >;
Subroutine BEGIN: called CC=1 SCAR=0.0
13 183 ▶use Ref::Util qw< is_ref is_arrayref is_globref is_scalarref is_regexpref >;
Subroutine BEGIN: called CC=1 SCAR=0.0
14 183 ▶use Sub::Util qw/ set_subname subname /;
Subroutine BEGIN: called CC=1 SCAR=0.0
15  
16 183 ▶use Plack::App::File;
Subroutine BEGIN: called CC=1 SCAR=0.0
17 183 ▶use Plack::Middleware::FixMissingBodyInRedirect;
Subroutine BEGIN: called CC=1 SCAR=0.0
18 183 ▶use Plack::Middleware::Head;
Subroutine BEGIN: called CC=1 SCAR=0.0
19 183 ▶use Plack::Middleware::Conditional;
Subroutine BEGIN: called CC=1 SCAR=0.0
20 183 ▶use Plack::Middleware::ConditionalGET;
Subroutine BEGIN: called CC=1 SCAR=0.0
21  
22 183 ▶use Dancer2::ConfigReader;
Subroutine BEGIN: called CC=1 SCAR=0.0
23 183 ▶use Dancer2::Core;
Subroutine BEGIN: called CC=1 SCAR=0.0
24 183 ▶use Dancer2::Core::Cookie;
Subroutine BEGIN: called CC=1 SCAR=0.0
25 183 ▶use Dancer2::Core::HTTP;
Subroutine BEGIN: called CC=1 SCAR=0.0
26 183 ▶use Dancer2::Core::Error;
Subroutine BEGIN: called CC=1 SCAR=0.0
27 183 ▶use Dancer2::Core::Types;
Subroutine BEGIN: called CC=1 SCAR=0.0
28 183 ▶use Dancer2::Core::Route;
Subroutine BEGIN: called CC=1 SCAR=0.0
29 183 ▶use Dancer2::Core::Hook;
Subroutine BEGIN: called CC=1 SCAR=0.0
30 183 ▶use Dancer2::Core::Request;
Subroutine BEGIN: called CC=1 SCAR=0.0
31 183 ▶use Dancer2::Core::Factory;
Subroutine BEGIN: called CC=1 SCAR=0.0
32  
33 183 ▶our $EVAL_SHIM; $EVAL_SHIM ||= sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
34 3878 my $code = shift;
35 3878 $code->(@_);
36 183 ▶};
Condition33%1/3
$Dancer2::Core::App::EVAL_SHIM ||= sub { my $code = shift(); &$code(@_); }
l!l&&r!l&&!r
01830
MC/DC0%0/2
$Dancer2::Core::App::EVAL_SHIM ||= sub { my $code = shift(); &$code(@_); }
$Dancer2::Core::App::EVAL_SHIM sub { my $code = shift(); &$code(@_); }
Truth table33%1/3
A ||= B
A= $Dancer2::Core::App::EVAL_SHIMB= sub { my $code = shift(); &$code(@_); }
ABresult
1X1
011
000
37  
38  
39 # we have hooks here
40 183 with qw<
41 Dancer2::Core::Role::Hookable
42 Dancer2::Core::Role::HasConfig
43 Dancer2::Core::Role::HasLocation
44 Dancer2::Core::Role::HasEnvironment
45 >;
46  
47 329 ▶sub supported_engines { [ qw<logger serializer session template> ] }
Subroutine supported_engines: called CC=1 SCAR=0.0
Pod undocumented
48  
49 39 ▶sub with_plugins {
Subroutine with_plugins: called CC=1 SCAR=0.0
Pod documented
50 39 my ( $self, @plugins ) = @_;
51 39 return map $self->_with_plugin($_), @plugins;
52  
53 }
54  
55 39 ▶sub _with_plugin {
Subroutine _with_plugin: called CC=6 SCAR=18.1
56 39 my( $self, $plugin ) = @_;
57  
58 39 ▶ if ( is_ref($plugin) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (is_ref($plugin)) 1 38 39
59 # passing the plugin as an already-created object
60  
61 # already loaded?
62 1 ▶ if( my ( $already ) = grep { ref($plugin) eq ref $_; } @{ $self->plugins } ) {
Branch: 1 branch
BranchTrueFalseTotal
if (my($already) = grep({ref $plugin eq ref $_;} @{$self->plugins;})) { } 0 1 1
63 0 ▶ die "trying to load two different objects for plugin ". ref $plugin
Branch: 1 branch
BranchTrueFalseTotal
if refaddr($plugin) != $already->refaddr 0 0 0
64 if refaddr($plugin) != refaddr $already ;
65  
66 }
67 else {
68 1 push @{ $self->plugins }, $plugin;
69 }
70  
71 1 return $plugin;
72 }
73  
74 # short plugin names get Dancer2::Plugin:: prefix
75 # plugin names starting with a '+' are full package names
76 38 ▶ if ( $plugin !~ s/^\+// ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($plugin =~ s/^\+//) 7 31 38
77 7 $plugin =~ s/^(?!Dancer2::Plugin::)/Dancer2::Plugin::/;
78 }
79  
80 # check if it's already there
81 38 ▶ if( my ( $already ) = grep { $plugin eq ref $_ } @{ $self->plugins } ) {
Branch: 1 branch
BranchTrueFalseTotal
if (my($already) = grep({$plugin eq ref $_;} @{$self->plugins;})) 2 36 38
82 2 return $already;
83 }
84  
85 36 push @{ $self->plugins },
86 $plugin = use_module($plugin)->new( app => $self );
87  
88 36 return $plugin;
89 }
90  
91 39 ▶sub with_plugin {
Subroutine with_plugin: called CC=2 SCAR=7.1
Pod documented
92 39 my( $self, $plugin ) = @_;
93  
94 39 ▶ croak "expected a single argument"
Branch: 1 branch
BranchTrueFalseTotal
unless @_ == 2 0 39 39
95 unless @_ == 2;
96  
97 39 ( $self->with_plugins($plugin) )[0];
98 }
99  
100 has _factory => (
101 is => 'ro',
102 isa => InstanceOf['Dancer2::Core::Factory'],
103 lazy => 1,
104 292 ▶ default => sub { Dancer2::Core::Factory->new },
Subroutine __ANON__: called CC=1 SCAR=0.0
105 183 );
106  
107 183 has logger_engine => (
108 is => 'ro',
109 isa => ConsumerOf['Dancer2::Core::Role::Logger'],
110 lazy => 1,
111 builder => '_build_logger_engine',
112 writer => 'set_logger_engine',
113 );
114  
115 183 has session_engine => (
116 is => 'ro',
117 isa => ConsumerOf['Dancer2::Core::Role::SessionFactory'],
118 lazy => 1,
119 builder => '_build_session_engine',
120 writer => 'set_session_engine',
121 );
122  
123 183 has template_engine => (
124 is => 'ro',
125 isa => ConsumerOf['Dancer2::Core::Role::Template'],
126 lazy => 1,
127 builder => '_build_template_engine',
128 writer => 'set_template_engine',
129 );
130  
131 183 has serializer_engine => (
132 is => 'ro',
133 isa => ConsumerOf['Dancer2::Core::Role::Serializer'],
134 lazy => 1,
135 builder => '_build_serializer_engine',
136 writer => 'set_serializer_engine',
137 predicate => 'has_serializer_engine',
138 );
139  
140 183 has _appdir_path => (
141 is => 'ro',
142 lazy => 1,
143 builder => '_build_appdir_path',
144 init_arg => undef,
145 );
146  
147 183 has _views_path => (
148 is => 'ro',
149 lazy => 1,
150 builder => '_build_views_path',
151 init_arg => undef,
152 );
153  
154 183 has _public_dir_path => (
155 is => 'ro',
156 lazy => 1,
157 builder => '_build_public_dir_path',
158 init_arg => undef,
159 );
160  
161 # compile_hooks() wraps each registered hook and writes the wrappers back
162 # via replace_hook. finish() (and therefore compile_hooks) can legitimately
163 # run more than once -- to_app() calls finish() every time it's invoked --
164 # and re-wrapping an already-wrapped hook would make a single dying hook
165 # report itself once per layer, so a dying hook fired core.app.hook_exception
166 # once, then twice, then three times as to_app was called again.
167 #
168 # This records every wrapper compile_hooks has produced, keyed by address,
169 # so a later run recognises its own work and passes it through instead of
170 # wrapping it a second time. It is deliberately per-hook rather than a
171 # per-app "already compiled" flag: hooks can still be registered after the
172 # first compile -- finish() adds postponed plugin hooks immediately after
173 # calling compile_hooks -- and those must still get wrapped when a later
174 # to_app() comes round.
175 has _compiled_hooks => (
176 is => 'ro',
177 isa => HashRef,
178 295 ▶ default => sub { +{} },
Subroutine __ANON__: called CC=1 SCAR=0.0
179 183 init_arg => undef,
180 );
181  
182 has '+local_triggers' => (
183 295 ▶ default => sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
184 295 my $self = shift;
185 my $triggers = {
186 # general triggers we want to allow, besides engines
187 20 ▶ views => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
188 20 my $self = shift;
189 20 my $value = shift;
190 20 $self->template_engine->views($value);
191 },
192  
193 3 ▶ layout => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
194 3 my $self = shift;
195 3 my $value = shift;
196 3 $self->template_engine->layout($value);
197 },
198  
199 1 ▶ layout_dir => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
200 1 my $self = shift;
201 1 my $value = shift;
202 1 $self->template_engine->layout_dir($value);
203 },
204  
205 6 ▶ log => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
206 6 my ( $self, $value, $config ) = @_;
207  
208 # This will allow to set the log level
209 # using: set log => warning
210 6 $self->logger_engine->log_level($value);
211 },
212  
213 1 ▶ default_mime_type => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
214 1 my $self = shift;
215 1 my $value = shift;
216 1 $self->mime_type->default($value);
217 },
218 295 };
219  
220 295 foreach my $engine ( @{ $self->supported_engines } ) {
221 125 ▶ $triggers->{$engine} = sub {
Subroutine __ANON__: called CC=4 SCAR=13.9
222 125 my $self = shift;
223 125 my $value = shift;
224 125 my $config = shift;
225  
226 125 ▶ is_ref($value) and return $value;
Branch: 1 branch
BranchTrueFalseTotal
is_ref($value) and return $value 4 121 125
227  
228 121 my $build_method = "_build_${engine}_engine";
229 121 my $setter_method = "set_${engine}_engine";
230 121 my $engine_instance = $self->$build_method( $value, $config );
231  
232 # set the engine with the new value from the builder
233 120 $self->$setter_method($engine_instance);
234 120 ▶ if ( $engine eq 'serializer' && $self->has_response ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($engine eq "serializer" and $self->has_response) 1 119 120
Condition100%3/3
$engine eq "serializer" and $self->has_response
!ll&&!rl&&r
93261
MC/DC100%2/2
$engine eq "serializer" and $self->has_response
$engine eq "serializer" $self->has_response
Truth table100%3/3
A and B
A= $engine eq "serializer"B= $self->has_response
ABresult
0X0
100
111
235 1 $self->response->serializer($engine_instance);
236 }
237  
238 120 return $engine_instance;
239 1180 };
240 }
241  
242 295 return $triggers;
243 },
244 183 );
245  
246 has 'mime_type' => (
247 'is' => 'ro',
248 'isa' => InstanceOf['Dancer2::Core::MIME'],
249 295 ▶ 'default' => sub { Dancer2::Core::MIME->new() },
Subroutine __ANON__: called CC=1 SCAR=0.0
250 183 );
251  
252 217 ▶sub _build_logger_engine {
Subroutine _build_logger_engine: called CC=7 SCAR=19.5
253 217 my $self = shift;
254 217 my $value = shift;
255 217 my $config = shift;
256  
257 217 ▶ defined $config or $config = $self->config;
Branch: 1 branch
BranchTrueFalseTotal
defined $config or $config = $self->config 50 167 217
258 217 ▶ defined $value or $value = $config->{logger};
Branch: 1 branch
BranchTrueFalseTotal
defined $value or $value = $config->{"logger"} 48 169 217
259  
260 217 ▶ is_ref($value) and return $value;
Branch: 1 branch
BranchTrueFalseTotal
is_ref($value) and return $value 1 216 217
261  
262 # XXX This is needed for the tests that create an app without
263 # a runner.
264 216 ▶ defined $value or $value = 'console';
Branch: 1 branch
BranchTrueFalseTotal
defined $value or $value = "console" 216 0 216
265  
266 216 ▶ is_module_name($value)
Branch: 1 branch
BranchTrueFalseTotal
&is_module_name($value) or croak("Cannot load logger engine '${value}': illegal module name") 215 1 216
267 or croak "Cannot load logger engine '$value': illegal module name";
268  
269 215 my $engine_options =
270 $self->_get_config_for_engine( logger => $value, $config );
271  
272 my $logger = $self->_factory->create(
273 logger => $value,
274 215 %{$engine_options},
275 location => $self->config_reader->config_location,
276 environment => $self->environment,
277 app_name => $self->name,
278 postponed_hooks => $self->postponed_hooks
279 );
280  
281 215 ▶ exists $config->{log} and $logger->log_level($config->{log});
Branch: 1 branch
BranchTrueFalseTotal
exists $config->{"log"} and $logger->log_level($config->{"log"}) 170 45 215
282  
283 215 return $logger;
284 }
285  
286 226 ▶sub _build_session_engine {
Subroutine _build_session_engine: called CC=6 SCAR=17.9
287 226 my $self = shift;
288 226 my $value = shift;
289 226 my $config = shift;
290  
291 226 ▶ defined $config or $config = $self->config;
Branch: 1 branch
BranchTrueFalseTotal
defined $config or $config = $self->config 26 200 226
292 226 ▶ defined $value or $value = $config->{'session'} || 'simple';
Branch: 1 branch
BranchTrueFalseTotal
defined $value or $value = $config->{"session"} || "simple" 24 202 226
Condition100%2/2
$config->{'session'} || 'simple'
l!l
13189
MC/DC100%1/1
$config->{'session'} || 'simple'
$config->{'session'}
Truth table100%2/2
A
A= $config->{'session'}
Aresult
11
00
293  
294 226 ▶ is_ref($value) and return $value;
Branch: 1 branch
BranchTrueFalseTotal
is_ref($value) and return $value 3 223 226
295  
296 223 ▶ is_module_name($value)
Branch: 1 branch
BranchTrueFalseTotal
&is_module_name($value) or croak("Cannot load session engine '${value}': illegal module name") 222 1 223
297 or croak "Cannot load session engine '$value': illegal module name";
298  
299 222 my $engine_options =
300 $self->_get_config_for_engine( session => $value, $config );
301  
302 222 Scalar::Util::weaken( my $weak_self = $self );
303  
304 # Note that engine options will replace the default session_dir (if provided).
305 return $self->_factory->create(
306 session => $value,
307 session_dir => $self->_appdir_path->child('sessions')->stringify,
308 222 %{$engine_options},
309 postponed_hooks => $self->postponed_hooks,
310  
311 3 ▶ log_cb => sub { $weak_self->log(@_) },
Subroutine __ANON__: called CC=1 SCAR=0.0
312 222 );
313 }
314  
315 219 ▶sub _build_template_engine {
Subroutine _build_template_engine: called CC=7 SCAR=19.6
316 219 my $self = shift;
317 219 my $value = shift;
318 219 my $config = shift;
319  
320 219 ▶ defined $config or $config = $self->config;
Branch: 1 branch
BranchTrueFalseTotal
defined $config or $config = $self->config 24 195 219
321 219 ▶ defined $value or $value = $config->{'template'};
Branch: 1 branch
BranchTrueFalseTotal
defined $value or $value = $config->{"template"} 22 197 219
322  
323 219 ▶ defined $value or return;
Branch: 1 branch
BranchTrueFalseTotal
defined $value or return 219 0 219
324 219 ▶ is_ref($value) and return $value;
Branch: 1 branch
BranchTrueFalseTotal
is_ref($value) and return $value 0 219 219
325  
326 219 ▶ is_module_name($value)
Branch: 1 branch
BranchTrueFalseTotal
&is_module_name($value) or croak("Cannot load template engine '${value}': illegal module name") 218 1 219
327 or croak "Cannot load template engine '$value': illegal module name";
328  
329 218 my $engine_options =
330 $self->_get_config_for_engine( template => $value, $config );
331  
332 my $engine_attrs = {
333 config => $engine_options,
334 layout => $config->{layout},
335 layout_dir => ( $config->{layout_dir} || 'layouts' ),
336 views => $config->{views},
337 charset => $config->{charset},
338 218 ▶ };
Condition50%1/2
$config->{'layout_dir'} || 'layouts'
l!l
0218
MC/DC0%0/1
$config->{'layout_dir'} || 'layouts'
$config->{'layout_dir'}
Truth table50%1/2
A
A= $config->{'layout_dir'}
Aresult
11
00
339  
340 218 Scalar::Util::weaken( my $weak_self = $self );
341  
342 return $self->_factory->create(
343 template => $value,
344 218 %{$engine_attrs},
345 postponed_hooks => $self->postponed_hooks,
346  
347 21 ▶ log_cb => sub { $weak_self->log(@_) },
Subroutine __ANON__: called CC=1 SCAR=0.0
348 218 );
349 }
350  
351 27 ▶sub _build_serializer_engine {
Subroutine _build_serializer_engine: called CC=6 SCAR=18.9
352 27 my $self = shift;
353 27 my $value = shift;
354 27 my $config = shift;
355  
356 27 ▶ defined $config or $config = $self->config;
Branch: 1 branch
BranchTrueFalseTotal
defined $config or $config = $self->config 27 0 27
357 27 ▶ defined $value or $value = $config->{serializer};
Branch: 1 branch
BranchTrueFalseTotal
defined $value or $value = $config->{"serializer"} 27 0 27
358  
359 27 ▶ defined $value or return;
Branch: 1 branch
BranchTrueFalseTotal
defined $value or return 27 0 27
360 27 ▶ is_ref($value) and return $value;
Branch: 1 branch
BranchTrueFalseTotal
is_ref($value) and return $value 0 27 27
361  
362 27 my $engine_options =
363 $self->_get_config_for_engine( serializer => $value, $config );
364 27 ▶ $engine_options->{strict_utf8} //= $config->{strict_utf8};
Condition33%1/3
$engine_options->{"strict_utf8"} //= $config->{"strict_utf8"}
l!l&&r!l&&!r
0270
MC/DC0%0/2
$engine_options->{"strict_utf8"} //= $config->{"strict_utf8"}
$engine_options->{"strict_utf8"} $config->{"strict_utf8"}
Truth table33%1/3
A //= B
A= $engine_options->{"strict_utf8"}B= $config->{"strict_utf8"}
ABresult
1X1
011
000
365  
366 27 Scalar::Util::weaken( my $weak_self = $self );
367  
368 return $self->_factory->create(
369 serializer => $value,
370 config => $engine_options,
371 postponed_hooks => $self->postponed_hooks,
372  
373 7 ▶ log_cb => sub { $weak_self->log(@_) },
Subroutine __ANON__: called CC=1 SCAR=0.0
374 27 );
375 }
376  
377 688 ▶sub _get_config_for_engine {
Subroutine _get_config_for_engine: called CC=6 SCAR=17.9
378 688 my $self = shift;
379 688 my $engine = shift;
380 688 my $name = shift;
381 688 my $config = shift;
382  
383 688 ▶ defined $config->{'engines'} && defined $config->{'engines'}{$engine}
Branch: 1 branch
BranchTrueFalseTotal
defined $config->{"engines"} and defined $config->{"engines"}{$engine} or return {} 28 660 688
Condition100%3/3
defined $config->{"engines"} and defined $config->{"engines"}{$engine}
!ll&&!rl&&r
6322828
MC/DC100%2/2
defined $config->{"engines"} and defined $config->{"engines"}{$engine}
defined $config->{"engines"} defined $config->{"engines"}{$engine}
Truth table100%3/3
A and B
A= defined $config->{"engines"}B= defined $config->{"engines"}{$engine}
ABresult
0X0
100
111
384 or return {};
385  
386 # try name, camelized name and fully-qualified name (without plus)
387 28 my $full_name = $name;
388 28 my $was_fully_qualified = ( $full_name =~ s/^\+// ); # strip any leading '+'
389 28 my $engine_config = {};
390 28 ▶ foreach my $engine_name (
Branch: 1 branch
BranchTrueFalseTotal
$was_fully_qualified ? : 1 27 28
391 $name,
392 Dancer2::Core::camelize($name),
393 ( $was_fully_qualified ? $full_name : () )
394 ) {
395 37 ▶ if ( defined $config->{'engines'}{$engine}{$engine_name} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $config->{"engines"}{$engine}{$engine_name}) 24 13 37
396 24 $engine_config = $config->{'engines'}{$engine}{$engine_name};
397 24 last;
398 }
399 }
400  
401 28 return $engine_config;
402 }
403  
404 has postponed_hooks => (
405 is => 'ro',
406 isa => HashRef,
407 44 ▶ default => sub { {} },
Subroutine __ANON__: called CC=1 SCAR=0.0
408 183 );
409  
410 # TODO I'd be happier with a HashRef, really
411 has plugins => (
412 is => 'rw',
413 isa => ArrayRef,
414 295 ▶ default => sub { [] },
Subroutine __ANON__: called CC=1 SCAR=0.0
415 183 );
416  
417 has route_handlers => (
418 is => 'rw',
419 isa => ArrayRef,
420 295 ▶ default => sub { [] },
Subroutine __ANON__: called CC=1 SCAR=0.0
421 183 );
422  
423 has name => (
424 is => 'ro',
425 isa => Str,
426 33 ▶ default => sub { (caller(1))[0] },
Subroutine __ANON__: called CC=1 SCAR=0.0
427 183 );
428  
429 183 has request => (
430 is => 'ro',
431 isa => InstanceOf['Dancer2::Core::Request'],
432 writer => '_set_request',
433 clearer => 'clear_request',
434 predicate => 'has_request',
435 );
436  
437 924 ▶sub set_request {
Subroutine set_request: called CC=3 SCAR=11.0
Pod undocumented
438 924 my ($self, $request, $defined_engines) = @_;
439 # typically this is passed in as an optimization within the
440 # dispatch loop but may be called elsewhere
441 924 ▶ $defined_engines ||= $self->defined_engines;
Condition66%2/3
$defined_engines ||= $self->defined_engines
l!l&&r!l&&!r
8001240
MC/DC0%0/2
$defined_engines ||= $self->defined_engines
$defined_engines $self->defined_engines
Truth table66%2/3
A ||= B
A= $defined_enginesB= $self->defined_engines
ABresult
1X1
011
000
442 # populate request in app and all engines
443 924 $self->_set_request($request);
444 924 Scalar::Util::weaken( my $weak_request = $request );
445 924 $_->set_request( $weak_request ) for @{$defined_engines};
446 }
447  
448 183 has response => (
449 is => 'ro',
450 isa => InstanceOf['Dancer2::Core::Response'],
451 lazy => 1,
452 writer => 'set_response',
453 clearer => 'clear_response',
454 builder => '_build_response',
455 predicate => 'has_response',
456 );
457  
458 183 has with_return => (
459 is => 'ro',
460 predicate => 1,
461 writer => 'set_with_return',
462 clearer => 'clear_with_return',
463 );
464  
465 183 has session => (
466 is => 'ro',
467 isa => InstanceOf['Dancer2::Core::Session'],
468 lazy => 1,
469 builder => '_build_session',
470 writer => 'set_session',
471 clearer => 'clear_session',
472 predicate => '_has_session',
473 );
474  
475 183 has config_reader => (
476 is => 'ro',
477 isa => InstanceOf['Dancer2::ConfigReader'],
478 lazy => 0,
479 builder => '_build_config_reader',
480 );
481  
482 295 ▶sub _build_config_reader {
Subroutine _build_config_reader: called CC=2 SCAR=7.0
483 295 my ($self) = @_;
484 my $cfgr = Dancer2::ConfigReader->new(
485 environment => $self->environment,
486 295 ▶ location => $ENV{DANCER_CONFDIR} || $self->location,
Condition66%2/3
$ENV{'DANCER_CONFDIR'} || $self->location
l!l&&r!l&&!r
62890
MC/DC0%0/2
$ENV{'DANCER_CONFDIR'} || $self->location
$ENV{'DANCER_CONFDIR'} $self->location
Truth table66%2/3
A || B
A= $ENV{'DANCER_CONFDIR'}B= $self->location
ABresult
1X1
011
000
487 default_config => $self->_build_default_config(),
488 );
489 295 return $cfgr;
490 }
491  
492 183 has '+config' => (
493 is => 'ro',
494 isa => HashRef,
495 lazy => 1,
496 builder => '_build_config',
497 );
498  
499 295 ▶sub _build_config {
Subroutine _build_config: called CC=4 SCAR=13.9
500 295 my ($self) = @_;
501  
502 295 my $config_reader = $self->config_reader;
503 295 my $config = $config_reader->config;
504  
505 293 ▶ if ( $config && $config->{'engines'} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($config and $config->{"engines"}) 4 289 293
Condition66%2/3
$config and $config->{"engines"}
!ll&&!rl&&r
02894
MC/DC50%1/2
$config and $config->{"engines"}
$config $config->{"engines"}
Truth table66%2/3
A and B
A= $configB= $config->{"engines"}
ABresult
0X0
100
111
506 4 $self->_validate_engine($_) for keys %{ $config->{'engines'} };
507 }
508  
509 292 return $config;
510 }
511  
512 872 ▶sub _build_response {
Subroutine _build_response: called CC=2 SCAR=7.6
513 872 my $self = shift;
514 return Dancer2::Core::Response->new(
515 mime_type => $self->mime_type,
516 server_tokens => !$self->config->{'no_server_tokens'},
517 charset => $self->config->{charset},
518 strict_utf8 => $self->config->{strict_utf8},
519 872 do {
520 872 Scalar::Util::weaken( my $weak_self = $self );
521 0 ▶ log_cb => sub { $weak_self && $weak_self->log(@_) };
Subroutine __ANON__: not called CC=2 SCAR=9.2
Branch: 2 branches
BranchTrueFalseTotal
$self->has_serializer_engine ? : 115 757 872
$weak_self and $weak_self->log(@_) 0 0 0
522 },
523 $self->has_serializer_engine
524 ? ( serializer => $self->serializer_engine )
525 : (),
526 );
527 }
528  
529 113 ▶sub _build_session {
Subroutine _build_session: called CC=8 SCAR=21.0
530 113 my $self = shift;
531 113 my $session;
532  
533 # Find the session engine
534 113 my $engine = $self->session_engine;
535  
536 # find the session cookie if any
537 113 ▶ if ( !$self->has_destroyed_session ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->has_destroyed_session) 108 5 113
538 108 my $session_id;
539 108 my $session_cookie = $self->cookie( $engine->cookie_name );
540 108 ▶ defined $session_cookie and
Branch: 1 branch
BranchTrueFalseTotal
defined $session_cookie and $session_id = $session_cookie->value 60 48 108
541 $session_id = $session_cookie->value;
542  
543 # if we have a session cookie, try to retrieve the session
544 108 ▶ if ( defined $session_id ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $session_id) 60 48 108
545 eval {
546 60 ▶ $EVAL_SHIM->(sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
547 60 $session = $engine->retrieve( id => $session_id );
548 60 });
549 53 1;
550 }
551 60 ▶ or do {
Branch: 1 branch
BranchTrueFalseTotal
eval { do { &$Dancer2::Core::App::EVAL_SHIM(sub { $session = $engine->retrieve("id", $session_id); } ); 1 } } or do { my $err = $@ || "Zombie Error"; if (not $err =~ /Unable to retrieve session/) { croak("Failed to retrieve session: $err"); } else { () } } 53 7 60
552 7 ▶ my $err = $@ || "Zombie Error";
Condition50%1/2
$@ || 'Zombie Error'
l!l
70
MC/DC0%0/1
$@ || 'Zombie Error'
$@
Truth table50%1/2
A
A= $@
Aresult
11
00
553 7 ▶ if ( $err !~ /Unable to retrieve session/ ) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $err =~ /Unable to retrieve session/) { } 0 7 7
554 0 croak "Failed to retrieve session: $err"
555 } else {
556 # XXX we throw away the error entirely? Why?
557 }
558 };
559 }
560 }
561  
562 # create the session if none retrieved
563 113 ▶ return $session ||= $engine->create();
Condition66%2/3
$session ||= $engine->create
l!l&&r!l&&!r
53600
MC/DC0%0/2
$session ||= $engine->create
$session $engine->create
Truth table66%2/3
A ||= B
A= $sessionB= $engine->create
ABresult
1X1
011
000
564 }
565  
566 1193 ▶sub has_session {
Subroutine has_session: called CC=3 SCAR=11.0
Pod documented
567 1193 my $self = shift;
568  
569 1193 my $engine = $self->session_engine;
570  
571 1193 ▶ return $self->_has_session
Condition100%6/6
$self->_has_session || $self->cookie($engine->cookie_name) && !$self->has_destroyed_session
l!l&&r!l&&!r
57037586
$self->cookie($engine->cookie_name) and not $self->has_destroyed_session
!ll&&!rl&&r
5731337
MC/DC100%3/3
$self->_has_session || $self->cookie($engine->cookie_name) && !$self->has_destroyed_session
$self->_has_session $self->cookie($engine->cookie_name) not $self->has_destroyed_session
Truth table100%4/4
A || B and not(C)
A= $self->_has_sessionB= $self->cookie($engine->cookie_name)C= not $self->has_destroyed_session
ABCresult
1XX1
0111
00X0
0100
572 || ( $self->cookie( $engine->cookie_name )
573 && !$self->has_destroyed_session );
574 }
575  
576 183 has destroyed_session => (
577 is => 'ro',
578 isa => InstanceOf ['Dancer2::Core::Session'],
579 predicate => 1,
580 writer => 'set_destroyed_session',
581 clearer => 'clear_destroyed_session',
582 );
583  
584 has 'prep_apps' => (
585 'is' => 'ro',
586 'isa' => ArrayRef,
587 295 ▶ 'default' => sub { [] },
Subroutine __ANON__: called CC=1 SCAR=0.0
588 183 );
589  
590 2 ▶sub find_plugin {
Subroutine find_plugin: called CC=2 SCAR=6.9
Pod undocumented
591 2 my ( $self, $name ) = @_;
592 2 ▶ my $plugin = List::Util::first { ref($_) eq $name } @{ $self->plugins };
Subroutine __ANON__: called CC=1 SCAR=0.0
593 2 ▶ $plugin or return;
Branch: 1 branch
BranchTrueFalseTotal
$plugin or return 1 1 2
594 1 return $plugin;
595 }
596  
597 18 ▶sub destroy_session {
Subroutine destroy_session: called CC=2 SCAR=6.9
Pod documented
598 18 my $self = shift;
599  
600 # Find the session engine
601 18 my $engine = $self->session_engine;
602  
603 # Expire session, set the expired cookie and destroy the session
604 # Setting the cookie ensures client gets an expired cookie unless
605 # a new session is created and supercedes it
606 18 my $session = $self->session;
607 18 $session->expires(-86400); # yesterday
608 18 $engine->destroy( id => $session->id );
609  
610 # Invalidate session cookie in request
611 # and clear session in app and engines
612 18 $self->set_destroyed_session($session);
613 18 $self->clear_session;
614 18 $_->clear_session for @{ $self->defined_engines };
615  
616 18 return;
617 }
618  
619 149 ▶sub setup_session {
Subroutine setup_session: called CC=3 SCAR=11.1
Pod undocumented
620 149 my $self = shift;
621  
622 149 for my $engine ( @{ $self->defined_engines } ) {
623 448 ▶ $self->has_session ?
Branch: 1 branch
BranchTrueFalseTotal
$self->has_session ? : 448 0 448
624 $engine->set_session( $self->session ) :
625 $engine->clear_session;
626 }
627 }
628  
629 6 ▶sub change_session_id {
Subroutine change_session_id: called CC=4 SCAR=13.9
Pod documented
630 6 my $self = shift;
631  
632 6 my $session = $self->session;
633  
634 # Find the session engine
635 6 my $engine = $self->session_engine;
636  
637 6 ▶ if ($engine->can('_change_id')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($engine->can('_change_id')) { } 4 2 6
638  
639 # session engine can change session ID
640 4 $engine->change_id( session => $session );
641 }
642 else {
643  
644 # Method order is important in here...
645 #
646 # On session build if there is no destroyed session then the session
647 # builder tries to recreate the session using the existing session
648 # cookie. We really don't want to do that in this case so it is
649 # important to create the new session before the
650 # clear_destroyed_session method is called.
651 #
652 # This sucks.
653 #
654 # Sawyer suggested:
655 #
656 # What if you take the session cookie logic out of that attribute into
657 # another attribute and clear that attribute?
658 # That would force the session rebuilt to rebuilt the attribute and
659 # get a different cookie value, no?
660 #
661 # TODO: think about this some more.
662  
663 # grab data, destroy session and store data again
664 2 my %data = %{$session->data};
665  
666 # destroy existing session
667 2 $self->destroy_session;
668  
669 # get new session
670 2 $session = $self->session;
671  
672 # write data from old session into new
673 # Some engines add session id to data so skip id.
674 2 ▶ while (my ($key, $value) = each %data ) {
Branch: 1 branch
BranchTrueFalseTotal
if (() = each %data) 2 2 4
675 2 ▶ $session->write($key => $value) unless $key eq 'id';
Branch: 1 branch
BranchTrueFalseTotal
unless $key eq "id" 2 0 2
676 }
677  
678 # clear out destroyed session - no longer relevant
679 2 $self->clear_destroyed_session;
680 }
681  
682 6 return $session->id;
683 }
684  
685 has prefix => (
686 is => 'rw',
687 isa => Maybe [Dancer2Prefix],
688 predicate => 1,
689 18 ▶ coerce => sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
690 18 my $prefix = shift;
691 18 ▶ defined($prefix) and $prefix eq "/" and return;
Branch: 1 branch
BranchTrueFalseTotal
defined $prefix and $prefix eq "/" and return 2 16 18
Condition100%3/3
defined $prefix and $prefix eq "/"
!ll&&!rl&&r
4122
MC/DC100%2/2
defined $prefix and $prefix eq "/"
defined $prefix $prefix eq "/"
Truth table100%3/3
A and B
A= defined $prefixB= $prefix eq "/"
ABresult
0X0
100
111
692 16 return $prefix;
693 },
694 183 );
695  
696 # routes registry, stored by method:
697 has routes => (
698 is => 'rw',
699 isa => HashRef,
700 295 ▶ default => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
701 295 { get => [],
702 head => [],
703 post => [],
704 put => [],
705 del => [],
706 options => [],
707 };
708 },
709 183 );
710  
711 has 'route_names' => (
712 'is' => 'rw',
713 'isa' => HashRef,
714 295 ▶ 'default' => sub { {} },
Subroutine __ANON__: called CC=1 SCAR=0.0
715 183 );
716  
717 # add_hook will add the hook to the first "hook candidate" it finds that support
718 # it. If none, then it will try to add the hook to the current application.
719 408 ▶around add_hook => sub {
Subroutine __ANON__: called CC=10 SCAR=23.2
720 408 my $orig = shift;
721 408 my $self = shift;
722  
723 # saving caller information
724 408 my ( $package, $file, $line ) = caller(4); # deep to 4 : user's app code
725 408 my $add_hook_caller = [ $package, $file, $line ];
726  
727 408 my ($hook) = @_;
728 408 my $name = $hook->name;
729 408 my $hook_aliases = $self->all_hook_aliases;
730  
731 # look for an alias
732 408 ▶ defined $hook_aliases->{$name} and $name = $hook_aliases->{$name};
Branch: 1 branch
BranchTrueFalseTotal
defined $hook_aliases->{$name} and $name = $hook_aliases->{$name} 80 328 408
733 408 $hook->name($name);
734  
735 # if that hook belongs to the app, register it now and return
736 408 ▶ $self->has_hook($name) and return $self->$orig(@_);
Branch: 1 branch
BranchTrueFalseTotal
$self->has_hook($name) and return $self->$orig(@_) 358 50 408
737  
738 # at this point the hook name must be formatted like:
739 # '$type.$candidate.$name', eg: 'engine.template.before_render' or
740 # 'plugin.database.before_dbi_connect'
741 50 my ( $hookable_type, $hookable_name, $hook_name ) = split( /\./, $name );
742  
743 50 ▶ ( defined $hookable_name && defined $hook_name )
Branch: 1 branch
BranchTrueFalseTotal
defined $hookable_name and defined $hook_name or croak("Invalid hook name `${name}'") 50 0 50
Condition33%1/3
defined $hookable_name and defined $hook_name
!ll&&!rl&&r
0050
MC/DC0%0/2
defined $hookable_name and defined $hook_name
defined $hookable_name defined $hook_name
Truth table33%1/3
A and B
A= defined $hookable_nameB= defined $hook_name
ABresult
0X0
100
111
744 or croak "Invalid hook name `$name'";
745  
746 50 ▶ grep /^$hookable_type$/, qw(core engine handler plugin)
Branch: 1 branch
BranchTrueFalseTotal
grep /^$hookable_type$/, ("core", "engine", "handler", "plugin") or croak("Unknown hook type `${hookable_type}'") 50 0 50
747 or croak "Unknown hook type `$hookable_type'";
748  
749 # register the hooks for existing hookable candidates
750 50 foreach my $hookable ( $self->hook_candidates ) {
751 154 ▶ $hookable->has_hook($name) and $hookable->add_hook(@_);
Branch: 1 branch
BranchTrueFalseTotal
$hookable->has_hook($name) and $hookable->add_hook(@_) 48 106 154
752 }
753  
754 # we register the hook for upcoming objects;
755 # that way, each components that can claim the hook will have a chance
756 # to register it.
757  
758 50 my $postponed_hooks = $self->postponed_hooks;
759  
760 # Hmm, so the hook was not claimed, at this point we'll cache it and
761 # register it when the owner is instantiated
762 50 ▶ $postponed_hooks->{$hookable_type}{$hookable_name} ||= {};
Condition100%2/2
$postponed_hooks->{$hookable_type}{$hookable_name} ||= {}
l!l
2921
MC/DC100%1/1
$postponed_hooks->{$hookable_type}{$hookable_name} ||= {}
$postponed_hooks->{$hookable_type}{$hookable_name}
Truth table100%2/2
A
A= $postponed_hooks->{$hookable_type}{$hookable_name}
Aresult
11
00
763 50 ▶ $postponed_hooks->{$hookable_type}{$hookable_name}{$name} ||= {};
Condition100%2/2
$postponed_hooks->{$hookable_type}{$hookable_name}{$name} ||= {}
l!l
743
MC/DC100%1/1
$postponed_hooks->{$hookable_type}{$hookable_name}{$name} ||= {}
$postponed_hooks->{$hookable_type}{$hookable_name}{$name}
Truth table100%2/2
A
A= $postponed_hooks->{$hookable_type}{$hookable_name}{$name}
Aresult
11
00
764 50 $postponed_hooks->{$hookable_type}{$hookable_name}{$name}{hook} = $hook;
765 $postponed_hooks->{$hookable_type}{$hookable_name}{$name}{caller} =
766 50 $add_hook_caller;
767  
768 223 };
769  
770 2012 ▶around execute_hook => sub {
Subroutine __ANON__: called CC=4 SCAR=13.9
771 2012 my $orig = shift;
772 2012 my $self = shift;
773  
774 2012 local $Dancer2::Core::Route::REQUEST = $self->request;
775 2012 local $Dancer2::Core::Route::RESPONSE = $self->response;
776  
777 2012 my ( $hook, @args ) = @_;
778 2012 ▶ if ( !$self->has_hook($hook) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->has_hook($hook)) 5 2007 2012
779 5 foreach my $cand ( $self->hook_candidates ) {
780 26 ▶ $cand->has_hook($hook) and return $cand->execute_hook(@_);
Branch: 1 branch
BranchTrueFalseTotal
$cand->has_hook($hook) and return $cand->execute_hook(@_) 2 24 26
781 }
782 }
783  
784 2010 return $self->$orig(@_);
785 223 };
786  
787 295 ▶sub _build_default_config {
Subroutine _build_default_config: called CC=7 SCAR=24.9
788 295 my $self = shift;
789  
790 295 ▶ my $public = $ENV{DANCER_PUBLIC} || $self->_location_path->child('public')->stringify;
Condition33%1/3
$ENV{'DANCER_PUBLIC'} || $self->_location_path->child('public')->stringify
l!l&&r!l&&!r
02950
MC/DC0%0/2
$ENV{'DANCER_PUBLIC'} || $self->_location_path->child('public')->stringify
$ENV{'DANCER_PUBLIC'} $self->_location_path->child('public')->stringify
Truth table33%1/3
A || B
A= $ENV{'DANCER_PUBLIC'}B= $self->_location_path->child('public')->stringify
ABresult
1X1
011
000
791 return {
792 content_type => ( $ENV{DANCER_CONTENT_TYPE} || 'text/html' ),
793 charset => ( $ENV{DANCER_CHARSET} || 'UTF-8' ),
794 strict_utf8 => ( $ENV{DANCER_STRICT_UTF8} || 0 ),
795 logger => ( $ENV{DANCER_LOGGER} || 'console' ),
796 views => ( $ENV{DANCER_VIEWS}
797 295 ▶ || $self->_location_path->child('views')->stringify ),
Condition45%5/11
$ENV{'DANCER_CONTENT_TYPE'} || 'text/html'
l!l
0295
$ENV{'DANCER_CHARSET'} || 'UTF-8'
l!l
0295
$ENV{'DANCER_STRICT_UTF8'} || 0
l!l
0295
$ENV{'DANCER_LOGGER'} || 'console'
l!l
0295
$ENV{'DANCER_VIEWS'} || $self->_location_path->child('views')->stringify
l!l&&r!l&&!r
02950
MC/DC0%0/1
$ENV{'DANCER_CONTENT_TYPE'} || 'text/html'
$ENV{'DANCER_CONTENT_TYPE'}
MC/DC0%0/1
$ENV{'DANCER_CHARSET'} || 'UTF-8'
$ENV{'DANCER_CHARSET'}
MC/DC0%0/1
$ENV{'DANCER_STRICT_UTF8'} || 0
$ENV{'DANCER_STRICT_UTF8'}
MC/DC0%0/1
$ENV{'DANCER_LOGGER'} || 'console'
$ENV{'DANCER_LOGGER'}
MC/DC0%0/2
$ENV{'DANCER_VIEWS'} || $self->_location_path->child('views')->stringify
$ENV{'DANCER_VIEWS'} $self->_location_path->child('views')->stringify
Truth table50%1/2
A
A= $ENV{'DANCER_CONTENT_TYPE'}
Aresult
11
00
Truth table50%1/2
A
A= $ENV{'DANCER_CHARSET'}
Aresult
11
00
Truth table50%1/2
A
A= $ENV{'DANCER_STRICT_UTF8'}
Aresult
11
00
Truth table50%1/2
A
A= $ENV{'DANCER_LOGGER'}
Aresult
11
00
Truth table33%1/3
A || B
A= $ENV{'DANCER_VIEWS'}B= $self->_location_path->child('views')->stringify
ABresult
1X1
011
000
798 environment => $self->environment,
799 appdir => $self->location,
800 public_dir => $public,
801 template => 'Tiny',
802 strict_config => 0, # We can look at changing this in a future version
803 route_handlers => [
804 [
805 AutoPage => 1
806 ],
807 ],
808 };
809 }
810  
811 211 ▶sub _build_appdir_path {
Subroutine _build_appdir_path: called CC=2 SCAR=8.1
812 211 my $self = shift;
813 211 ▶ return Path::Tiny::path( $self->config->{appdir} || $self->location );
Condition33%1/3
$self->config->{'appdir'} || $self->location
l!l&&r!l&&!r
21100
MC/DC0%0/2
$self->config->{'appdir'} || $self->location
$self->config->{'appdir'} $self->location
Truth table33%1/3
A || B
A= $self->config->{'appdir'}B= $self->location
ABresult
1X1
011
000
814 }
815  
816 0 ▶sub _build_views_path {
Subroutine _build_views_path: not called CC=1 SCAR=6.9
817 0 my $self = shift;
818 0 return Path::Tiny::path( $self->config->{views} );
819 }
820  
821 163 ▶sub _build_public_dir_path {
Subroutine _build_public_dir_path: called CC=3 SCAR=13.3
822 163 my $self = shift;
823 my $dir = $ENV{DANCER_PUBLIC}
824 || $self->config->{public_dir}
825 163 ▶ || $self->_location_path->child('public')->stringify;
Condition33%2/6
$ENV{'DANCER_PUBLIC'} || $self->config->{'public_dir'} || $self->_location_path->child('public')->stringify
l!l&&r!l&&!r
16300
$ENV{"DANCER_PUBLIC"} or $self->config->{"public_dir"}
l!l&&r!l&&!r
01630
MC/DC0%0/3
$ENV{'DANCER_PUBLIC'} || $self->config->{'public_dir'} || $self->_location_path->child('public')->stringify
$ENV{"DANCER_PUBLIC"} $self->config->{"public_dir"} $self->_location_path->child('public')->stringify
Truth table25%1/4
A or B || C
A= $ENV{"DANCER_PUBLIC"}B= $self->config->{"public_dir"}C= $self->_location_path->child('public')->stringify
ABCresult
1XX1
01X1
0011
0000
826 163 return Path::Tiny::path($dir);
827 }
828  
829 292 ▶sub _init_hooks {
Subroutine _init_hooks: called CC=1 SCAR=0.0
830 292 my $self = shift;
831  
832 # Hook to flush the session at the end of the request,
833 # this way, we're sure we flush only once per request
834 #
835 # Note: we create a weakened copy $self
836 # before closing over the weakened copy
837 # to avoid circular memory refs.
838 292 Scalar::Util::weaken(my $app = $self);
839  
840 $self->add_hook(
841 Dancer2::Core::Hook->new(
842 name => 'core.app.after_request',
843 623 ▶ code => sub {
Subroutine __ANON__: called CC=6 SCAR=17.9
844 623 my $response = $Dancer2::Core::Route::RESPONSE;
845  
846 # make sure an engine is defined, if not, nothing to do
847 623 my $engine = $app->session_engine;
848 623 ▶ defined $engine or return;
Branch: 1 branch
BranchTrueFalseTotal
defined $engine or return 623 0 623
849  
850 # if a session has been instantiated or we already had a
851 # session, first flush the session so cookie-based sessions can
852 # update the session ID if needed, then set the session cookie
853 # in the response
854 #
855 # if there is NO session object but the request has a cookie with
856 # a session key, create a dummy session with the same ID (without
857 # actually retrieving and flushing immediately) and generate the
858 # cookie header from the dummy session. Lazy Sessions FTW!
859  
860 623 ▶ if ( $app->has_session ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($app->has_session) { } 95 528 623
elsif ($app->has_destroyed_session) { } 13 515 528
861 95 my $session;
862 95 ▶ if ( $app->_has_session ) { # Session object exists
Branch: 1 branch
BranchTrueFalseTotal
if ($app->_has_session) { } 91 4 95
863 91 $session = $app->session;
864 91 ▶ $session->is_dirty and $engine->flush( session => $session );
Branch: 1 branch
BranchTrueFalseTotal
$session->is_dirty and $engine->flush("session", $session) 59 32 91
865 }
866 else { # Cookie header exists. Create a dummy session object
867 4 my $cookie = $app->cookie( $engine->cookie_name );
868 4 my $session_id = $cookie->value;
869 4 $session = Dancer2::Core::Session->new( id => $session_id );
870 }
871 95 $engine->set_cookie_header(
872 response => $response,
873 session => $session
874 );
875 }
876 elsif ( $app->has_destroyed_session ) {
877 13 my $session = $app->destroyed_session;
878 13 $engine->set_cookie_header(
879 response => $response,
880 session => $session,
881 destroyed => 1
882 );
883 }
884 },
885 )
886 292 );
887 }
888  
889 580 ▶sub supported_hooks {
Subroutine supported_hooks: called CC=1 SCAR=0.0
Pod undocumented
890 580 qw/
891 core.app.before_request
892 core.app.after_request
893 core.app.route_exception
894 core.app.hook_exception
895 core.app.before_file_render
896 core.app.after_file_render
897 core.error.before
898 core.error.after
899 core.error.init
900 /;
901 }
902  
903 2428 ▶sub hook_aliases {
Subroutine hook_aliases: called CC=2 SCAR=6.9
Pod undocumented
904 2428 my $self = shift;
905 2428 ▶ $self->{'hook_aliases'} ||= {
Condition100%2/2
$self->{"hook_aliases"} ||= {"before", "core.app.before_request", "before_request", "core.app.before_request", "after", "core.app.after_request", "after_request", "core.app.after_request", "init_error", "core.error.init", "before_error", "core.error.before", "after_error", "core.error.after", "on_route_exception", "core.app.route_exception", "on_hook_exception", "core.app.hook_exception", "before_file_render", "core.app.before_file_render", "after_file_render", "core.app.after_file_render", "before_handler_file_render", "handler.file.before_render", "after_handler_file_render", "handler.file.after_render", "before_error_render", "core.error.before", "after_error_render", "core.error.after", "before_error_init", "core.error.init", "before_template_render", "engine.template.before_render", "after_template_render", "engine.template.after_render", "before_layout_render", "engine.template.before_layout_render", "after_layout_render", "engine.template.after_layout_render", "before_serializer", "engine.serializer.before", "after_serializer", "engine.serializer.after"}
l!l
2136292
MC/DC100%1/1
$self->{"hook_aliases"} ||= {"before", "core.app.before_request", "before_request", "core.app.before_request", "after", "core.app.after_request", "after_request", "core.app.after_request", "init_error", "core.error.init", "before_error", "core.error.before", "after_error", "core.error.after", "on_route_exception", "core.app.route_exception", "on_hook_exception", "core.app.hook_exception", "before_file_render", "core.app.before_file_render", "after_file_render", "core.app.after_file_render", "before_handler_file_render", "handler.file.before_render", "after_handler_file_render", "handler.file.after_render", "before_error_render", "core.error.before", "after_error_render", "core.error.after", "before_error_init", "core.error.init", "before_template_render", "engine.template.before_render", "after_template_render", "engine.template.after_render", "before_layout_render", "engine.template.before_layout_render", "after_layout_render", "engine.template.after_layout_render", "before_serializer", "engine.serializer.before", "after_serializer", "engine.serializer.after"}
$self->{"hook_aliases"}
Truth table100%2/2
A
A= $self->{"hook_aliases"}
Aresult
11
00
906 before => 'core.app.before_request',
907 before_request => 'core.app.before_request',
908 after => 'core.app.after_request',
909 after_request => 'core.app.after_request',
910 init_error => 'core.error.init',
911 before_error => 'core.error.before',
912 after_error => 'core.error.after',
913 on_route_exception => 'core.app.route_exception',
914 on_hook_exception => 'core.app.hook_exception',
915  
916 before_file_render => 'core.app.before_file_render',
917 after_file_render => 'core.app.after_file_render',
918 before_handler_file_render => 'handler.file.before_render',
919 after_handler_file_render => 'handler.file.after_render',
920  
921  
922 # compatibility from Dancer1
923 before_error_render => 'core.error.before',
924 after_error_render => 'core.error.after',
925 before_error_init => 'core.error.init',
926  
927 # TODO: call $engine->hook_aliases as needed
928 # But.. currently there are use cases where hook_aliases
929 # are needed before the engines are intiialized :(
930 before_template_render => 'engine.template.before_render',
931 after_template_render => 'engine.template.after_render',
932 before_layout_render => 'engine.template.before_layout_render',
933 after_layout_render => 'engine.template.after_layout_render',
934 before_serializer => 'engine.serializer.before',
935 after_serializer => 'engine.serializer.after',
936 };
937 }
938  
939 2077 ▶sub defined_engines {
Subroutine defined_engines: called CC=2 SCAR=6.9
Pod undocumented
940 2077 my $self = shift;
941 return [
942 2077 ▶ $self->template_engine,
Branch: 1 branch
BranchTrueFalseTotal
$self->has_serializer_engine ? : 227 1850 2077
943 $self->session_engine,
944 $self->logger_engine,
945 $self->has_serializer_engine
946 ? $self->serializer_engine
947 : (),
948 ];
949 }
950  
951 0 ▶sub register_plugin {
Subroutine register_plugin: not called CC=1 SCAR=6.9
Pod documented
952 0 my $self = shift;
953 0 my $plugin = shift;
954  
955 0 $self->log( core => "Registered $plugin");
956  
957 0 push @{ $self->plugins }, $plugin;
958 }
959  
960 # This method overrides the default one from Role::ConfigReader
961 1230 ▶sub settings {
Subroutine settings: called CC=1 SCAR=0.0
Pod undocumented
962 1230 my $self = shift;
963 1230 +{ %{ Dancer2::runner()->config }, %{ $self->config } };
964 }
965  
966 908 ▶sub cleanup {
Subroutine cleanup: called CC=2 SCAR=6.9
Pod undocumented
967 908 my $self = shift;
968 908 $self->clear_request;
969 908 $self->clear_response;
970 908 $self->clear_session;
971 908 $self->clear_destroyed_session;
972 # Clear engine attributes
973 908 for my $engine ( @{ $self->defined_engines } ) {
974 2836 $engine->clear_session;
975 2836 $engine->clear_request;
976 }
977 }
978  
979 34 ▶sub _validate_engine {
Subroutine _validate_engine: called CC=2 SCAR=6.9
980 34 my $self = shift;
981 34 my $name = shift;
982  
983 34 ▶ grep +( $_ eq $name ), @{ $self->supported_engines }
Branch: 1 branch
BranchTrueFalseTotal
grep(($_ eq $name), @{$self->supported_engines;}) or croak("Engine '${name}' is not supported.") 32 2 34
984 or croak "Engine '$name' is not supported.";
985 }
986  
987 30 ▶sub engine {
Subroutine engine: called CC=1 SCAR=0.0
Pod undocumented
988 30 my $self = shift;
989 30 my $name = shift;
990  
991 30 $self->_validate_engine($name);
992  
993 29 my $attr_name = "${name}_engine";
994 29 return $self->$attr_name;
995 }
996  
997 52 ▶sub template {
Subroutine template: called CC=7 SCAR=19.5
Pod undocumented
998 52 my $self = shift;
999  
1000 52 my $template = $self->template_engine;
1001 52 $template->set_settings( $self->config );
1002  
1003 # A session will not exist if there is no request (global keyword)
1004 #
1005 # A session may exist but the route code may not have instantiated
1006 # the session object (sessions are lazy). If this is the case, do
1007 # that now, so the templates have the session data for rendering.
1008 52 ▶ $self->has_request && $self->has_session && ! $template->has_session
Branch: 1 branch
BranchTrueFalseTotal
$self->has_request and $self->has_session and not $template->has_session and $self->setup_session 2 50 52
Condition100%6/6
$self->has_request and $self->has_session and not $template->has_session
!ll&&!rl&&r
4462
$self->has_request and $self->has_session
!ll&&!rl&&r
1438
MC/DC100%3/3
$self->has_request and $self->has_session and not $template->has_session
$self->has_request $self->has_session not $template->has_session
Truth table100%4/4
A and B and not(C)
A= $self->has_requestB= $self->has_sessionC= not $template->has_session
ABCresult
0XX0
10X0
1100
1111
1009 and $self->setup_session;
1010  
1011 # return content
1012 52 ▶ if ($self->has_with_return) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->has_with_return) 48 4 52
1013 48 my $old_with_return = $self->with_return;
1014 48 my $local_response;
1015 3 ▶ $self->set_with_return( sub {
Subroutine __ANON__: called CC=2 SCAR=9.2
1016 3 ▶ $local_response ||= shift;
Condition33%1/3
$local_response ||= shift()
l!l&&r!l&&!r
030
MC/DC0%0/2
$local_response ||= shift()
$local_response shift()
Truth table33%1/3
A ||= B
A= $local_responseB= shift()
ABresult
1X1
011
000
1017 48 });
1018 # Catch any exceptions that may happen during template processing
1019 48 my $content = eval { $template->process( @_ ) };
1020 48 my $eval_result = $@;
1021 48 $self->set_with_return($old_with_return);
1022 # If there was a previous response set before the exception (or set as
1023 # part of the exception handling), then use that, otherwise throw the
1024 # exception as normal
1025 48 ▶ if ($local_response) {
Branch: 2 branches
BranchTrueFalseTotal
if ($local_response) { } 3 45 48
elsif ($eval_result) { } 9 36 45
1026 3 $self->with_return->($local_response);
1027 } elsif ($eval_result) {
1028 9 die $eval_result;
1029 }
1030 36 return $content;
1031 }
1032 4 return $template->process( @_ );
1033 }
1034  
1035 55 ▶sub hook_candidates {
Subroutine hook_candidates: called CC=4 SCAR=14.1
Pod undocumented
1036 55 my $self = shift;
1037  
1038 55 my @engines = @{ $self->defined_engines };
1039  
1040 55 my @route_handlers;
1041 55 for my $handler ( @{ $self->route_handlers } ) {
1042 55 my $handler_code = $handler->{handler};
1043 55 ▶ blessed $handler_code and $handler_code->can('supported_hooks')
Branch: 1 branch
BranchTrueFalseTotal
builtin::blessed($handler_code) and $handler_code->can("supported_hooks") and push @route_handlers, $handler_code 0 55 55
Condition33%1/3
builtin::blessed($handler_code) and $handler_code->can("supported_hooks")
!ll&&!rl&&r
0550
MC/DC0%0/2
builtin::blessed($handler_code) and $handler_code->can("supported_hooks")
builtin::blessed($handler_code) $handler_code->can("supported_hooks")
Truth table33%1/3
A and B
A= builtin::blessed($handler_code)B= $handler_code->can("supported_hooks")
ABresult
0X0
100
111
1044 and push @route_handlers, $handler_code;
1045 }
1046  
1047 # TODO : get the list of all plugins registered
1048 55 my @plugins = @{ $self->plugins };
1049  
1050 55 ( @route_handlers, @engines, @plugins );
1051 }
1052  
1053 408 ▶sub all_hook_aliases {
Subroutine all_hook_aliases: called CC=2 SCAR=6.9
Pod undocumented
1054 408 my $self = shift;
1055  
1056 408 my $aliases = $self->hook_aliases;
1057 408 for my $plugin ( grep { $_->can('hook_aliases') } @{ $self->plugins } ) {
1058 13 $aliases = { %{$aliases}, %{ $plugin->hook_aliases } };
1059 }
1060  
1061 408 return $aliases;
1062 }
1063  
1064 3647 ▶sub log {
Subroutine log: called CC=2 SCAR=7.0
Pod undocumented
1065 3647 my $self = shift;
1066 3647 my $level = shift;
1067  
1068 3647 ▶ my $logger = $self->logger_engine
Branch: 1 branch
BranchTrueFalseTotal
my $logger = $self->logger_engine or croak("No logger defined") 3647 0 3647
1069 or croak "No logger defined";
1070  
1071 3647 $logger->$level(@_);
1072 }
1073  
1074 11 ▶sub send_as {
Subroutine send_as: called CC=15 SCAR=28.9
Pod undocumented
1075 11 my $self = shift;
1076 11 my ( $type, $data, $options ) = @_;
1077 11 ▶ $options ||= {};
Condition100%2/2
$options ||= {}
l!l
110
MC/DC100%1/1
$options ||= {}
$options
Truth table100%2/2
A
A= $options
Aresult
11
00
1078  
1079 11 ▶ $type or croak "Can not send_as using an undefined type";
Branch: 1 branch
BranchTrueFalseTotal
$type or croak("Can not send_as using an undefined type") 10 1 11
1080  
1081 10 ▶ if ( lc($type) eq 'html' || lc($type) eq 'plain' ) {
Branch: 1 branch
BranchTrueFalseTotal
if (lc $type eq "html" or lc $type eq "plain") 5 5 10
Condition100%3/3
lc $type eq "html" or lc $type eq "plain"
l!l&&r!l&&!r
235
MC/DC100%2/2
lc $type eq "html" or lc $type eq "plain"
lc $type eq "html" lc $type eq "plain"
Truth table100%3/3
A or B
A= lc $type eq "html"B= lc $type eq "plain"
ABresult
1X1
011
000
1082 5 ▶ if ( $type ne lc $type ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($type ne lc $type) 0 5 5
1083 0 local $Carp::CarpLevel = 2;
1084 0 carp sprintf( "Please use %s as the type for 'send_as', not %s", lc($type), $type );
1085 }
1086  
1087 5 ▶ $options->{charset} //= $self->config->{charset};
Condition33%1/3
$options->{"charset"} //= $self->config->{"charset"}
l!l&&r!l&&!r
050
MC/DC0%0/2
$options->{"charset"} //= $self->config->{"charset"}
$options->{"charset"} $self->config->{"charset"}
Truth table33%1/3
A //= B
A= $options->{"charset"}B= $self->config->{"charset"}
ABresult
1X1
011
000
1088 5 my $content = $data;
1089 5 ▶ if ( defined $options->{charset} && length $options->{charset} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $options->{"charset"} and length $options->{"charset"}) 5 0 5
Condition33%1/3
defined $options->{"charset"} and length $options->{"charset"}
!ll&&!rl&&r
005
MC/DC0%0/2
defined $options->{"charset"} and length $options->{"charset"}
defined $options->{"charset"} length $options->{"charset"}
Truth table33%1/3
A and B
A= defined $options->{"charset"}B= length $options->{"charset"}
ABresult
0X0
100
111
1090 5 $content = Encode::encode( $options->{charset}, $data );
1091 }
1092 5 ▶ $options->{content_type} ||= join '/', 'text', lc $type;
Condition33%1/3
$options->{"content_type"} ||= join("/", "text", lc $type)
l!l&&r!l&&!r
050
MC/DC0%0/2
$options->{"content_type"} ||= join("/", "text", lc $type)
$options->{"content_type"} join("/", "text", lc $type)
Truth table33%1/3
A ||= B
A= $options->{"content_type"}B= join("/", "text", lc $type)
ABresult
1X1
011
000
1093 # Explicit return needed here, as if we are currently rendering a
1094 # template then with_return will not longjump
1095 5 return $self->send_file( \$content, %$options );
1096 }
1097  
1098 # Try and load the serializer class
1099 5 my $serializer_class = "Dancer2::Serializer::$type";
1100 eval {
1101 5 ▶ $EVAL_SHIM->(sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1102 5 require_module( $serializer_class );
1103 5 });
1104 3 1;
1105 5 ▶ } or do {
Branch: 1 branch
BranchTrueFalseTotal
eval { do { &$Dancer2::Core::App::EVAL_SHIM(sub { &require_module($serializer_class); } ); 1 } } or do { my $err = $@ || "Zombie Error"; croak("Unable to load serializer class for ${type}: $err") } 3 2 5
1106 2 ▶ my $err = $@ || "Zombie Error";
Condition50%1/2
$@ || 'Zombie Error'
l!l
20
MC/DC0%0/1
$@ || 'Zombie Error'
$@
Truth table50%1/2
A
A= $@
Aresult
11
00
1107 2 croak "Unable to load serializer class for $type: $err";
1108 };
1109  
1110 # load any serializer engine config
1111 3 ▶ my $engine_options =
Condition50%1/2
$self->_get_config_for_engine('serializer', $type, $self->config) || {}
l!l
30
MC/DC0%0/1
$self->_get_config_for_engine('serializer', $type, $self->config) || {}
$self->_get_config_for_engine('serializer', $type, $self->config)
Truth table50%1/2
A
A= $self->_get_config_for_engine('serializer', $type, $self->config)
Aresult
11
00
1112 $self->_get_config_for_engine( serializer => $type, $self->config ) || {};
1113 3 ▶ $engine_options->{strict_utf8} //= $self->config->{strict_utf8};
Condition66%2/3
$engine_options->{"strict_utf8"} //= $self->config->{"strict_utf8"}
l!l&&r!l&&!r
210
MC/DC0%0/2
$engine_options->{"strict_utf8"} //= $self->config->{"strict_utf8"}
$engine_options->{"strict_utf8"} $self->config->{"strict_utf8"}
Truth table66%2/3
A //= B
A= $engine_options->{"strict_utf8"}B= $self->config->{"strict_utf8"}
ABresult
1X1
011
000
1114  
1115 3 Scalar::Util::weaken( my $weak_self = $self );
1116 my $serializer = $self->_factory->create(
1117 serializer => $type,
1118 config => $engine_options,
1119 postponed_hooks => $self->postponed_hooks,
1120 0 ▶ log_cb => sub { $weak_self->log(@_) },
Subroutine __ANON__: not called CC=1 SCAR=6.9
1121 3 );
1122 3 my $content = $serializer->serialize( $data );
1123 3 ▶ $options->{content_type} ||= $serializer->content_type;
Condition66%2/3
$options->{"content_type"} ||= $serializer->content_type
l!l&&r!l&&!r
120
MC/DC0%0/2
$options->{"content_type"} ||= $serializer->content_type
$options->{"content_type"} $serializer->content_type
Truth table66%2/3
A ||= B
A= $options->{"content_type"}B= $serializer->content_type
ABresult
1X1
011
000
1124 3 $self->send_file( \$content, %$options );
1125 }
1126  
1127 20 ▶sub send_error {
Subroutine send_error: called CC=3 SCAR=11.3
Pod undocumented
1128 20 my $self = shift;
1129 20 my ( $message, $status ) = @_;
1130  
1131 my $err = Dancer2::Core::Error->new(
1132 message => $message,
1133 app => $self,
1134 charset => $self->config->{charset},
1135 20 ▶ ( status => $status )x!! $status,
Branch: 1 branch
BranchTrueFalseTotal
$self->has_serializer_engine ? : 2 18 20
1136  
1137 $self->has_serializer_engine
1138 ? ( serializer => $self->serializer_engine )
1139 : (),
1140 )->throw;
1141  
1142 # Immediately return to dispatch if with_return coderef exists
1143 20 ▶ $self->has_with_return && $self->with_return->($err);
Branch: 1 branch
BranchTrueFalseTotal
$self->has_with_return and $self->with_return->($err) 20 0 20
1144 0 return $err;
1145 }
1146  
1147 32 ▶sub send_file {
Subroutine send_file: called CC=30 SCAR=35.3
Pod undocumented
1148 32 my $self = shift;
1149 32 my $thing = shift;
1150 32 my %options = @_;
1151  
1152 32 my ($content_type, $charset, $file_path);
1153  
1154 # are we're given a filehandle? (based on what Plack::Middleware::Lint accepts)
1155 my $is_filehandle = Plack::Util::is_real_fh($thing)
1156 0 ▶ || ( is_globref($thing) && *{$thing}{IO} && *{$thing}{IO}->can('getline') )
Condition50%7/14
&Plack::Util::is_real_fh($thing) || is_globref($thing) && *{$thing;}{'IO'} && *{$thing;}{'IO'}->can('getline') || builtin::blessed($thing) && $thing->can('getline')
l!l&&r!l&&!r
1031
&Plack::Util::is_real_fh($thing) or is_globref($thing) and *{$thing;}{"IO"} and *{$thing;}{"IO"}->can("getline")
l!l&&r!l&&!r
1031
is_globref($thing) and *{$thing;}{"IO"} and *{$thing;}{"IO"}->can("getline")
!ll&&!rl&&r
3100
is_globref($thing) and *{$thing;}{"IO"}
!ll
310
builtin::blessed($thing) and $thing->can("getline")
!ll&&!rl&&r
3100
MC/DC20%1/5
&Plack::Util::is_real_fh($thing) || is_globref($thing) && *{$thing;}{'IO'} && *{$thing;}{'IO'}->can('getline') || builtin::blessed($thing) && $thing->can('getline')
&Plack::Util::is_real_fh($thing) is_globref($thing) *{$thing;}{"IO"}->can("getline") builtin::blessed($thing) $thing->can("getline")
Truth table25%2/8
A or B and C || D and E
A= &Plack::Util::is_real_fh($thing)B= is_globref($thing)C= *{$thing;}{"IO"}->can("getline")D= builtin::blessed($thing)E= $thing->can("getline")
ABCDEresult
1XXXX1
011XX1
00X111
010111
00X0X0
00X100
0100X0
010100
1157 || ( Scalar::Util::blessed($thing) && $thing->can('getline') );
1158 32 my ($fh) = ($thing)x!! $is_filehandle;
1159  
1160 # if we're given an IO::Scalar object, DTRT (take the scalar ref from it)
1161 32 ▶ if (Scalar::Util::blessed($thing) && $thing->isa('IO::Scalar')) {
Branch: 1 branch
BranchTrueFalseTotal
if (builtin::blessed($thing) and $thing->isa("IO::Scalar")) 0 32 32
Condition33%1/3
builtin::blessed($thing) and $thing->isa("IO::Scalar")
!ll&&!rl&&r
3200
MC/DC0%0/2
builtin::blessed($thing) and $thing->isa("IO::Scalar")
builtin::blessed($thing) $thing->isa("IO::Scalar")
Truth table33%1/3
A and B
A= builtin::blessed($thing)B= $thing->isa("IO::Scalar")
ABresult
0X0
100
111
1162 0 $thing = $thing->sref;
1163 }
1164  
1165 # if we're given a SCALAR reference, build a filehandle to it
1166 32 ▶ if ( is_scalarref($thing) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (is_scalarref($thing)) 10 22 32
1167 ## no critic qw(InputOutput::RequireCheckedOpen)
1168 10 open $fh, "<", $thing;
1169 }
1170  
1171 # If we haven't got a filehandle, create one to the requested content
1172 32 ▶ if (! $fh) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($fh) 21 11 32
1173 21 my $path = $thing;
1174 # remove prefix from given path (if not a filehandle)
1175 21 my $prefix = $self->prefix;
1176 21 ▶ if ( $prefix && $prefix ne '/' ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($prefix and $prefix ne "/") 0 21 21
Condition33%1/3
$prefix and $prefix ne "/"
!ll&&!rl&&r
2100
MC/DC0%0/2
$prefix and $prefix ne "/"
$prefix $prefix ne "/"
Truth table33%1/3
A and B
A= $prefixB= $prefix ne "/"
ABresult
0X0
100
111
1177 0 $path =~ s/^\Q$prefix\E//;
1178 }
1179 # static file dir - either system root or public_dir
1180 my $dir = $options{system_path}
1181 21 ▶ ? Path::Tiny->rootdir
Branch: 1 branch
BranchTrueFalseTotal
$options{'system_path'} ? : 5 16 21
1182 : $self->_public_dir_path;
1183  
1184 6 ▶ my $err_response = sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1185 6 my $status = shift;
1186 6 $self->response->status($status);
1187 6 $self->response->header( 'Content-Type', 'text/plain' );
1188 6 $self->response->content( Dancer2::Core::HTTP->status_message($status) );
1189 6 $self->with_return->( $self->response );
1190 21 };
1191  
1192 # resolve relative paths (with '../') as much as possible
1193 # On Windows, absolute paths (e.g., C:/foo) must not be joined with
1194 # the rootdir since Path::Tiny would produce an invalid /C:/foo path.
1195 21 my $pt_path = Path::Tiny::path($path);
1196 21 ▶ $file_path = ( $pt_path->is_absolute
Branch: 1 branch
BranchTrueFalseTotal
$pt_path->is_absolute ? : 6 15 21
1197 ? $pt_path
1198 : Path::Tiny::path( $dir, $path )
1199 )->realpath;
1200  
1201 # We need to check whether they are trying to access
1202 # a directory outside their scope
1203 21 ▶ $err_response->(403) if !$dir->realpath->subsumes($file_path);
Branch: 1 branch
BranchTrueFalseTotal
unless $dir->realpath->subsumes($file_path) 4 17 21
1204  
1205 # other error checks
1206 17 ▶ $err_response->(404) if !$file_path->exists;
Branch: 1 branch
BranchTrueFalseTotal
unless $file_path->exists 1 16 17
1207 16 ▶ $err_response->(403) if !$file_path->is_file;
Branch: 1 branch
BranchTrueFalseTotal
unless $file_path->is_file 0 16 16
1208 16 ▶ $err_response->(403) if !-r $file_path;
Branch: 1 branch
BranchTrueFalseTotal
unless -r $file_path 1 15 16
1209  
1210 # Read file content as bytes
1211 15 $fh = $file_path->openr_raw();
1212 15 ▶ $content_type = $self->mime_type->for_file($file_path) || 'text/plain';
Condition50%1/2
$self->mime_type->for_file($file_path) || 'text/plain'
l!l
150
MC/DC0%0/1
$self->mime_type->for_file($file_path) || 'text/plain'
$self->mime_type->for_file($file_path)
Truth table50%1/2
A
A= $self->mime_type->for_file($file_path)
Aresult
11
00
1213 15 ▶ if ( $content_type =~ m!^text/! ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($content_type =~ m[^text/]) 12 3 15
1214 12 $charset = $self->config->{charset};
1215 }
1216  
1217 # cleanup for other functions not assuming on Path::Tiny
1218 15 $file_path = $file_path->stringify;
1219 }
1220  
1221 # Now we are sure we can render the file...
1222 26 $self->execute_hook( 'core.app.before_file_render', $file_path );
1223  
1224 # response content type and charset
1225 26 ▶ ( exists $options{'content_type'} ) and $content_type = $options{'content_type'};
Branch: 1 branch
BranchTrueFalseTotal
exists $options{"content_type"} and $content_type = $options{"content_type"} 11 15 26
1226 26 ▶ ( exists $options{'charset'} ) and $charset = $options{'charset'};
Branch: 1 branch
BranchTrueFalseTotal
exists $options{"charset"} and $charset = $options{"charset"} 7 19 26
1227 26 ▶ $content_type .= "; charset=$charset" if $content_type and $charset;
Branch: 1 branch
BranchTrueFalseTotal
if $content_type and $charset 19 7 26
Condition100%3/3
$content_type and $charset
!ll&&!rl&&r
1619
MC/DC100%2/2
$content_type and $charset
$content_type $charset
Truth table100%3/3
A and B
A= $content_typeB= $charset
ABresult
0X0
100
111
1228 26 ▶ ( defined $content_type )
Branch: 1 branch
BranchTrueFalseTotal
defined $content_type and $self->response->header("Content-Type", $content_type) 25 1 26
1229 and $self->response->header('Content-Type' => $content_type );
1230  
1231 # content disposition
1232 ( exists $options{filename} )
1233 and $self->response->header( 'Content-Disposition' =>
1234 26 ▶ ($options{content_disposition} || "attachment") . "; filename=\"$options{filename}\"" );
Branch: 1 branch
BranchTrueFalseTotal
exists $options{"filename"} and $self->response->header("Content-Disposition", ($options{"content_disposition"} || "attachment") . qq[; filename="$options{"filename"}"]) 5 21 26
Condition100%2/2
$options{'content_disposition'} || 'attachment'
l!l
23
MC/DC100%1/1
$options{'content_disposition'} || 'attachment'
$options{'content_disposition'}
Truth table100%2/2
A
A= $options{'content_disposition'}
Aresult
11
00
1235  
1236 # use a delayed response unless server does not support streaming
1237 26 ▶ my $use_streaming = exists $options{streaming} ? $options{streaming} : 1;
Branch: 1 branch
BranchTrueFalseTotal
exists $options{'streaming'} ? : 2 24 26
1238 26 my $response;
1239 26 my $env = $self->request->env;
1240 26 ▶ if ( $env->{'psgi.streaming'} && $use_streaming ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($env->{'psgi.streaming'} and $use_streaming) { } 25 1 26
Condition66%2/3
$env->{"psgi.streaming"} and $use_streaming
!ll&&!rl&&r
0125
MC/DC50%1/2
$env->{"psgi.streaming"} and $use_streaming
$env->{"psgi.streaming"} $use_streaming
Truth table66%2/3
A and B
A= $env->{"psgi.streaming"}B= $use_streaming
ABresult
0X0
100
111
1241 25 ▶ my $cb = sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1242 25 my $responder = $Dancer2::Core::Route::RESPONDER;
1243 25 my $res = $Dancer2::Core::Route::RESPONSE;
1244 25 return $responder->(
1245 [ $res->status, $res->headers_to_array, $fh ]
1246 );
1247 25 };
1248  
1249 25 Scalar::Util::weaken( my $weak_self = $self );
1250  
1251 $response = Dancer2::Core::Response::Delayed->new(
1252 0 ▶ error_cb => sub { $weak_self->logger_engine->log( warning => @_ ) },
Subroutine __ANON__: not called CC=1 SCAR=6.9
1253 25 cb => $cb,
1254 request => $Dancer2::Core::Route::REQUEST,
1255 response => $Dancer2::Core::Route::RESPONSE,
1256 );
1257 }
1258 else {
1259 1 $response = $self->response;
1260 # direct assignment to hash element, avoids around modifier
1261 # trying to serialise this this content.
1262  
1263 # optimized slurp
1264 {
1265 ## no critic qw(Variables::RequireInitializationForLocalVars)
1266 1 local $/;
1267 1 $response->{'content'} = <$fh>;
1268 }
1269  
1270 1 $response->is_encoded(1); # bytes are already encoded
1271 }
1272  
1273 26 $self->execute_hook( 'core.app.after_file_render', $response );
1274 26 $self->with_return->( $response );
1275 }
1276  
1277 258 ▶sub BUILD {
Subroutine BUILD: called CC=1 SCAR=0.0
Pod undocumented
1278 258 my $self = shift;
1279 258 $self->init_route_handlers();
1280 257 $self->_init_hooks();
1281 }
1282  
1283 322 ▶sub finish {
Subroutine finish: called CC=5 SCAR=16.2
Pod undocumented
1284 285 my $self = shift;
1285  
1286 # normalize some values that require calculations
1287 defined $self->config->{'static_handler'}
1288 285 ▶ or $self->config->{'static_handler'} = -d $self->config->{'public_dir'};
Branch: 1 branch
BranchTrueFalseTotal
defined $self->config->{"static_handler"} or $self->config->{"static_handler"} = -d $self->config->{"public_dir"} 85 200 285
1289  
1290 285 $self->register_route_handlers;
1291 285 $self->compile_hooks;
1292  
1293 285 ▶ @{$self->plugins}
Branch: 1 branch
BranchTrueFalseTotal
@{$self->plugins;} and $self->plugins->[0]->can("_add_postponed_plugin_hooks") and $self->plugins->[0]->_add_postponed_plugin_hooks($self->postponed_hooks) 0 285 285
Condition66%2/3
@{$self->plugins;} and $self->plugins->[0]->can("_add_postponed_plugin_hooks")
!ll&&!rl&&r
265200
MC/DC0%0/2
@{$self->plugins;} and $self->plugins->[0]->can("_add_postponed_plugin_hooks")
@{$self->plugins;} $self->plugins->[0]->can("_add_postponed_plugin_hooks")
Truth table66%2/3
A and B
A= @{$self->plugins;}B= $self->plugins->[0]->can("_add_postponed_plugin_hooks")
ABresult
0X0
100
111
1294 && $self->plugins->[0]->can('_add_postponed_plugin_hooks')
1295 && $self->plugins->[0]->_add_postponed_plugin_hooks(
1296 $self->postponed_hooks
1297 );
1298  
1299 322 foreach my $prep_cb ( @{ $self->prep_apps } ) {
1300 108 $prep_cb->($self);
1301 }
1302 }
1303  
1304 258 ▶sub init_route_handlers {
Subroutine init_route_handlers: called CC=3 SCAR=11.0
Pod undocumented
1305 293 my $self = shift;
1306  
1307 292 my $handlers_config = $self->config->{route_handlers};
1308 291 for my $handler_data ( @{$handlers_config} ) {
1309 291 my ($handler_name, $config) = @{$handler_data};
1310 291 ▶ $config = {} if !is_ref($config);
Branch: 1 branch
BranchTrueFalseTotal
unless is_ref($config) 290 1 291
1311  
1312 257 my $handler = $self->_factory->create(
1313 Handler => $handler_name,
1314 app => $self,
1315 %$config,
1316 postponed_hooks => $self->postponed_hooks,
1317 );
1318  
1319 257 push @{ $self->route_handlers }, {
1320 name => $handler_name,
1321 handler => $handler,
1322 };
1323 }
1324 }
1325  
1326 288 ▶sub register_route_handlers {
Subroutine register_route_handlers: called CC=2 SCAR=6.9
Pod undocumented
1327 283 my $self = shift;
1328 283 for my $handler ( @{$self->route_handlers} ) {
1329 288 my $handler_code = $handler->{handler};
1330 864 $handler_code->register($self);
1331 }
1332 }
1333  
1334 389 ▶sub compile_hooks {
Subroutine compile_hooks: called CC=4 SCAR=13.9
Pod documented
1335 864 my ($self) = @_;
1336  
1337 864 for my $position ( $self->supported_hooks ) {
1338 2028 my $compiled_hooks = [];
1339 1971 for my $hook ( @{ $self->hooks->{$position} } ) {
1340 # Already a wrapper this method produced on an earlier run:
1341 # pass it through untouched. See _compiled_hooks.
1342 307 ▶ if ( $self->_compiled_hooks->{ Scalar::Util::refaddr($hook) } ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_compiled_hooks->{builtin::refaddr($hook)}) 101 263 364
1343 131 push @{$compiled_hooks}, $hook;
1344 131 next;
1345 }
1346  
1347 263 Scalar::Util::weaken( my $app = $self );
1348 553 ▶ my $compiled = set_subname subname($hook) => sub {
Subroutine __ANON__: called CC=9 SCAR=22.0
1349 # don't run the filter if halt has been used
1350 717 ▶ $Dancer2::Core::Route::RESPONSE &&
Branch: 1 branch
BranchTrueFalseTotal
$Dancer2::Core::Route::RESPONSE and $Dancer2::Core::Route::RESPONSE->is_halted and return 1 720 721
Condition66%2/3
$Dancer2::Core::Route::RESPONSE and $Dancer2::Core::Route::RESPONSE->is_halted
!ll&&!rl&&r
07201
MC/DC50%1/2
$Dancer2::Core::Route::RESPONSE and $Dancer2::Core::Route::RESPONSE->is_halted
$Dancer2::Core::Route::RESPONSE $Dancer2::Core::Route::RESPONSE->is_halted
Truth table66%2/3
A and B
A= $Dancer2::Core::Route::RESPONSEB= $Dancer2::Core::Route::RESPONSE->is_halted
ABresult
0X0
100
111
1351 $Dancer2::Core::Route::RESPONSE->is_halted
1352 and return;
1353  
1354 549 eval { $EVAL_SHIM->($hook,@_); 1; }
1355 549 ▶ or do {
Branch: 1 branch
BranchTrueFalseTotal
eval { do { &$Dancer2::Core::App::EVAL_SHIM($hook, @_); 1 } } or do { my $err = $@ || "Zombie Error"; my $is_hook_exception = $position eq "core.app.hook_exception"; $app->execute_hook("core.app.hook_exception", $app, $err, $position) unless $is_hook_exception; my $is_halted = $app->response->is_halted; $app->cleanup unless $is_hook_exception or $is_halted; return if $is_halted; $app->log("error", "Exception caught in '${position}' filter: $err"); croak("Exception caught in '${position}' filter: $err") } 698 15 713
1356 15 ▶ my $err = $@ || "Zombie Error";
Condition50%1/2
$@ || 'Zombie Error'
l!l
150
MC/DC0%0/1
$@ || 'Zombie Error'
$@
Truth table50%1/2
A
A= $@
Aresult
11
00
1357 15 my $is_hook_exception = $position eq 'core.app.hook_exception';
1358 # Don't execute the hook_exception hook if the exception
1359 # has been generated from a hook exception handler itself,
1360 # thus preventing potentially recursive code.
1361 15 ▶ $app->execute_hook( 'core.app.hook_exception', $app, $err, $position )
Branch: 1 branch
BranchTrueFalseTotal
unless $is_hook_exception 13 2 15
1362 unless $is_hook_exception;
1363 14 my $is_halted = $app->response->is_halted; # Capture before cleanup
1364 # We can't cleanup if we're in the hook for a hook
1365 # exception, as this would clear the custom response that
1366 # may have been set by the hook. However, there is no need
1367 # to do so, as the upper hook that called this hook
1368 # exception will perform the cleanup instead anyway.
1369 # Likewise, if the response has been halted, that halt
1370 # means "this response is final" -- cleanup would destroy
1371 # the request/response/session the dispatcher still needs
1372 # to read, letting the very route this halt was meant to
1373 # refuse run anyway.
1374 14 ▶ $app->cleanup
Branch: 1 branch
BranchTrueFalseTotal
unless $is_hook_exception or $is_halted 9 5 14
Condition100%3/3
$is_hook_exception or $is_halted
l!l&&r!l&&!r
239
MC/DC100%2/2
$is_hook_exception or $is_halted
$is_hook_exception $is_halted
Truth table100%3/3
A or B
A= $is_hook_exceptionB= $is_halted
ABresult
1X1
011
000
1375 unless $is_hook_exception || $is_halted;
1376 # Allow the hook function to halt the response, thus
1377 # retaining any response it may have set. Otherwise the
1378 # croak from this function will overwrite any content that
1379 # may have been set by the hook
1380 18 ▶ return if $is_halted;
Branch: 1 branch
BranchTrueFalseTotal
if $is_halted 4 10 14
1381 # Default behavior if nothing else defined
1382 14 $app->log('error', "Exception caught in '$position' filter: $err");
1383 14 croak "Exception caught in '$position' filter: $err";
1384 };
1385 263 };
1386  
1387 # Remember the wrapper -- by address, and by holding a reference
1388 # so its address cannot be reused by a later coderef -- so a
1389 # subsequent compile_hooks run recognises and skips it.
1390 854 $self->_compiled_hooks->{ Scalar::Util::refaddr($compiled) }
1391 = $compiled;
1392  
1393 379 push @{$compiled_hooks}, $compiled;
1394 }
1395 2116 $self->replace_hook( $position, $compiled_hooks );
1396 }
1397 }
1398  
1399 212 ▶sub lexical_prefix {
Subroutine lexical_prefix: called CC=8 SCAR=20.8
Pod documented
1400 5 my $self = shift;
1401 5 my $prefix = shift;
1402 5 my $cb = shift;
1403  
1404 5 ▶ $prefix eq '/' and undef $prefix;
Branch: 1 branch
BranchTrueFalseTotal
$prefix eq "/" and undef $prefix 1 4 5
1405  
1406 # save the app prefix
1407 5 my $app_prefix = $self->prefix;
1408  
1409 # alter the prefix for the callback
1410 5 ▶ my $new_prefix =
Branch: 2 branches
BranchTrueFalseTotal
defined $app_prefix ? : 2 3 5
defined $prefix ? : 4 1 5
1411 ( defined $app_prefix ? $app_prefix : '' )
1412 . ( defined $prefix ? $prefix : '' );
1413  
1414 # if the new prefix is empty, it's a meaningless prefix, just ignore it
1415 5 ▶ length $new_prefix and $self->prefix($new_prefix);
Branch: 1 branch
BranchTrueFalseTotal
length $new_prefix and $self->prefix($new_prefix) 4 1 5
1416  
1417 4 my $err;
1418 5 my $ok= eval { $EVAL_SHIM->($cb); 1 }
1419 1 ▶ or do { $err = $@ || "Zombie Error"; };
Branch: 1 branch
BranchTrueFalseTotal
my $ok = eval { do { &$Dancer2::Core::App::EVAL_SHIM($cb); 1 } } or do { $err = $@ || "Zombie Error" } 4 1 5
Condition50%1/2
$@ || 'Zombie Error'
l!l
10
MC/DC0%0/1
$@ || 'Zombie Error'
$@
Truth table50%1/2
A
A= $@
Aresult
11
00
1420  
1421 # restore app prefix
1422 212 $self->prefix($app_prefix);
1423  
1424 212 ▶ $ok or croak "Unable to run the callback for prefix '$prefix': $err";
Branch: 1 branch
BranchTrueFalseTotal
$ok or croak("Unable to run the callback for prefix '${prefix}': $err") 4 1 5
1425 }
1426  
1427 699 ▶sub add_route {
Subroutine add_route: called CC=4 SCAR=13.9
Pod documented
1428 911 my $self = shift;
1429 911 my %route_attrs = @_;
1430  
1431 my $route = Dancer2::Core::Route->new(
1432 type_library => $self->config->{type_library},
1433 911 prefix => $self->prefix,
1434 %route_attrs,
1435 );
1436  
1437 911 my $method = $route->method;
1438 706 push @{ $self->routes->{$method} }, $route;
1439  
1440 705 ▶ if ( $method ne 'head' && $route->has_name() ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method ne "head" and $route->has_name) 14 897 911
Condition100%3/3
$method ne "head" and $route->has_name
!ll&&!rl&&r
39750014
MC/DC100%2/2
$method ne "head" and $route->has_name
$method ne "head" $route->has_name
Truth table100%3/3
A and B
A= $method ne "head"B= $route->has_name
ABresult
0X0
100
111
1441 218 my $name = $route->name;
1442 7 ▶ $self->route_names->{$name}
Branch: 1 branch
BranchTrueFalseTotal
$self->route_names->{$name} and die "Route with this name ($name) already exists" 1 13 14
1443 and die "Route with this name ($name) already exists";
1444  
1445 7 $self->route_names->{$name} = $route;
1446 }
1447  
1448 699 return $route;
1449 }
1450  
1451 1 ▶sub route_exists {
Subroutine route_exists: called CC=3 SCAR=16.5
Pod documented
1452 0 my $self = shift;
1453 0 my $route = shift;
1454  
1455 0 my $routes = $self->routes->{ $route->method };
1456  
1457 1 foreach my $existing_route (@$routes) {
1458 1 ▶ $existing_route->spec_route eq $route->spec_route
Branch: 1 branch
BranchTrueFalseTotal
$existing_route->spec_route eq $route->spec_route and return 1 0 0 0
1459 and return 1;
1460 }
1461  
1462 1 return 0;
1463 }
1464  
1465 157 ▶sub routes_regexps_for {
Subroutine routes_regexps_for: called CC=1 SCAR=0.2
Pod documented
1466 1 my $self = shift;
1467 157 my $method = shift;
1468  
1469 0 return [ map $_->regexp, @{ $self->routes->{$method} } ];
1470 }
1471  
1472 581 ▶sub cookie {
Subroutine cookie: called CC=2 SCAR=6.9
Pod documented
1473 581 my $self = shift;
1474  
1475 581 ▶ @_ == 1 and return $self->request->cookies->{ $_[0] };
Branch: 1 branch
BranchTrueFalseTotal
@_ == 1 and return $self->request->cookies->{$_[0]} 735 3 738
1476  
1477 # writer
1478 3 my ( $name, $value, %options ) = @_;
1479 3 my $c =
1480 Dancer2::Core::Cookie->new( name => $name, value => $value, %options );
1481 3 $self->response->push_header( 'Set-Cookie' => $c->to_header );
1482 }
1483  
1484 36 ▶sub redirect {
Subroutine redirect: called CC=3 SCAR=11.0
Pod documented
1485 30 my $self = shift;
1486 30 my $destination = shift;
1487 30 my $status = shift;
1488  
1489 30 ▶ if ($destination =~ m{^/(?!/)}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($destination =~ m[^/(?!/)]) 15 15 30
1490 # If the app is mounted to something other than "/", we must
1491 # preserve its path.
1492 15 my $script_name = $self->request->script_name;
1493 15 $script_name =~ s{/$}{}; # Remove trailing slash (if present).
1494 21 $destination = $script_name . $destination;
1495 }
1496  
1497 36 $self->response->redirect( $destination, $status );
1498  
1499 # Short circuit any remaining before hook / route code
1500 # ('pass' and after hooks are still processed)
1501 36 ▶ $self->has_with_return
Branch: 1 branch
BranchTrueFalseTotal
$self->has_with_return and $self->with_return->($self->response) 30 0 30
1502 and $self->with_return->($self->response);
1503 }
1504  
1505 4 ▶sub halt {
Subroutine halt: called CC=2 SCAR=7.1
Pod documented
1506 4 my $self = shift;
1507 4 $self->response->halt( @_ );
1508  
1509 # Short citcuit any remaining hook/route code
1510 4 ▶ $self->has_with_return
Branch: 1 branch
BranchTrueFalseTotal
$self->has_with_return and $self->with_return->($self->response) 9 0 9
1511 and $self->with_return->($self->response);
1512 }
1513  
1514 2 ▶sub pass {
Subroutine pass: called CC=2 SCAR=7.1
Pod documented
1515 2 my $self = shift;
1516 2 $self->response->pass;
1517  
1518 # Short citcuit any remaining hook/route code
1519 2 ▶ $self->has_with_return
Branch: 1 branch
BranchTrueFalseTotal
$self->has_with_return and $self->with_return->($self->response) 3 0 3
1520 and $self->with_return->($self->response);
1521 }
1522  
1523 50 ▶sub forward {
Subroutine forward: called CC=2 SCAR=7.0
Pod documented
1524 50 my $self = shift;
1525 50 my $url = shift;
1526 50 my $params = shift;
1527 50 my $options = shift;
1528  
1529 50 my $new_request = $self->make_forward_to( $url, $params, $options );
1530  
1531 50 ▶ $self->has_with_return
Branch: 1 branch
BranchTrueFalseTotal
$self->has_with_return and $self->with_return->($new_request) 50 0 50
1532 and $self->with_return->($new_request);
1533  
1534 # nothing else will run after this
1535 }
1536  
1537 # Create a new request which is a clone of the current one, apart
1538 # from the path location, which points instead to the new location
1539 60 ▶sub make_forward_to {
Subroutine make_forward_to: called CC=5 SCAR=16.1
Pod documented
1540 59 my $self = shift;
1541 59 my $url = shift;
1542 59 my $params = shift;
1543 59 my $options = shift;
1544  
1545 59 my $overrides = { PATH_INFO => $url };
1546 exists $options->{method} and
1547 59 ▶ $overrides->{REQUEST_METHOD} = $options->{method};
Branch: 1 branch
BranchTrueFalseTotal
exists $options->{"method"} and $overrides->{"REQUEST_METHOD"} = $options->{"method"} 8 51 59
1548  
1549 # "clone" the existing request
1550 59 my $new_request = $self->request->_shallow_clone( $params, $overrides );
1551  
1552 # If a session object was created during processing of the original request
1553 # i.e. a session object exists but no cookie existed
1554 # add a cookie so the dispatcher can assign the session to the appropriate app
1555 59 my $engine = $self->session_engine;
1556 59 ▶ $engine && $self->_has_session or return $new_request;
Branch: 1 branch
BranchTrueFalseTotal
$engine and $self->_has_session or return $new_request 14 45 59
Condition66%2/3
$engine and $self->_has_session
!ll&&!rl&&r
04514
MC/DC50%1/2
$engine and $self->_has_session
$engine $self->_has_session
Truth table66%2/3
A and B
A= $engineB= $self->_has_session
ABresult
0X0
100
111
1557 14 my $name = $engine->cookie_name;
1558 15 ▶ exists $new_request->cookies->{$name} and return $new_request;
Branch: 1 branch
BranchTrueFalseTotal
exists $new_request->cookies->{$name} and return $new_request 1 13 14
1559 81 $new_request->cookies->{$name} =
1560 Dancer2::Core::Cookie->new( name => $name, value => $self->session->id );
1561  
1562 81 return $new_request;
1563 }
1564  
1565 68 ▶sub app { shift }
Subroutine app: called CC=1 SCAR=0.0
Pod documented
1566  
1567 # DISPATCHER
1568 420 ▶sub to_app {
Subroutine to_app: called CC=5 SCAR=16.1
Pod undocumented
1569 419 my $self = shift;
1570  
1571 # build engines
1572 {
1573 419 for ( qw<logger session template> ) {
1574 651 my $attr = "${_}_engine";
1575 713 $self->$attr;
1576 }
1577  
1578 # the serializer engine does not have a default
1579 # and is the only engine that can actually not have a value
1580 283 ▶ if ( $self->config->{'serializer'} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->config->{"serializer"}) 28 255 283
1581 90 $self->serializer_engine;
1582 }
1583 }
1584  
1585 283 $self->finish;
1586  
1587 804 ▶ my $psgi = sub {
Subroutine __ANON__: called CC=4 SCAR=13.9
1588 804 my $env = shift;
1589  
1590 # pre-request sanity check
1591 804 my $method = uc $env->{'REQUEST_METHOD'};
1592 804 ▶ $Dancer2::Core::Types::supported_http_methods{$method}
Branch: 1 branch
BranchTrueFalseTotal
$Dancer2::Core::Types::supported_http_methods{$method} or return [405, ["Content-Type", "text/plain"], ["Method Not Allowed\n\n$method is not supported."]] 802 3 805
1593 or return [
1594 405,
1595 [ 'Content-Type' => 'text/plain' ],
1596 [ "Method Not Allowed\n\n$method is not supported." ]
1597 ];
1598  
1599 802 my $response;
1600 eval {
1601 598 ▶ $EVAL_SHIM->(sub{ $response = $self->dispatch($env)->to_psgi });
Subroutine __ANON__: called CC=1 SCAR=0.0
1602 801 1;
1603 598 ▶ } or do {
Branch: 1 branch
BranchTrueFalseTotal
eval { do { &$Dancer2::Core::App::EVAL_SHIM(sub { $response = $self->dispatch($env)->to_psgi; } ); 1 } } or do { my $err = $@ || "Zombie Error"; return [500, ["Content-Type", "text/plain"], ["Internal Server Error\n\n$err"]] } 801 1 802
1604 205 ▶ my $err = $@ || "Zombie Error";
Condition50%1/2
$@ || 'Zombie Error'
l!l
10
MC/DC0%0/1
$@ || 'Zombie Error'
$@
Truth table50%1/2
A
A= $@
Aresult
11
00
1605 return [
1606 4 500,
1607 [ 'Content-Type' => 'text/plain' ],
1608 [ "Internal Server Error\n\n$err" ],
1609 ];
1610 };
1611  
1612 805 return $response;
1613 283 };
1614  
1615 # Only add static content handler if required
1616 283 ▶ if ( $self->config->{'static_handler'} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->config->{"static_handler"}) 239 44 283
1617 # Use App::File to "serve" the static content
1618 my $static_app = Plack::App::File->new(
1619 root => $self->_public_dir_path->stringify,
1620 215 ▶ content_type => sub { $self->mime_type->for_file( $_[0] ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1621 239 )->to_app;
1622 # Conditionally use the static handler wrapped with ConditionalGET
1623 # when the file exists. Otherwise the request passes into our app.
1624 $psgi = Plack::Middleware::Conditional->wrap(
1625 $psgi,
1626 586 ▶ condition => sub {
Subroutine __ANON__: called CC=5 SCAR=16.3
1627 586 my $env = shift;
1628 # A NUL byte in PATH_INFO makes Path::Tiny warn ("Invalid \0
1629 # character in pathname for ftis") when we ask it whether the
1630 # path is a file. "ftis" is not a typo on our part: it is
1631 # perl's own internal name for the file-test ops, quoted here
1632 # verbatim so this comment can be found from the warning text.
1633 # Refuse it here, before Path::Tiny ever sees it, so the
1634 # request just falls through to the app (which 404s, as it
1635 # always has) without the warning.
1636 return 0
1637 722 ▶ if defined $env->{'PATH_INFO'} && $env->{'PATH_INFO'} =~ /\0/;
Branch: 1 branch
BranchTrueFalseTotal
if defined $env->{"PATH_INFO"} and $env->{"PATH_INFO"} =~ /\0/ 1 725 726
Condition66%2/3
defined $env->{"PATH_INFO"} and $env->{"PATH_INFO"} =~ /\0/
!ll&&!rl&&r
07251
MC/DC50%1/2
defined $env->{"PATH_INFO"} and $env->{"PATH_INFO"} =~ /\0/
defined $env->{"PATH_INFO"} $env->{"PATH_INFO"} =~ /\0/
Truth table66%2/3
A and B
A= defined $env->{"PATH_INFO"}B= $env->{"PATH_INFO"} =~ /\0/
ABresult
0X0
100
111
1638 $self->_public_dir_path->child(
1639 defined $env->{'PATH_INFO'} && length $env->{'PATH_INFO'}
1640 721 ▶ ? ($env->{'PATH_INFO'})
Branch: 1 branch
BranchTrueFalseTotal
defined $env->{'PATH_INFO'} && length $env->{'PATH_INFO'} ? : 722 3 725
Condition66%2/3
defined $env->{"PATH_INFO"} and length $env->{"PATH_INFO"}
!ll&&!rl&&r
03722
MC/DC50%1/2
defined $env->{"PATH_INFO"} and length $env->{"PATH_INFO"}
defined $env->{"PATH_INFO"} length $env->{"PATH_INFO"}
Truth table66%2/3
A and B
A= defined $env->{"PATH_INFO"}B= length $env->{"PATH_INFO"}
ABresult
0X0
100
111
1641 : (),
1642 )->is_file;
1643 },
1644 375 ▶ builder => sub { Plack::Middleware::ConditionalGET->wrap( $static_app ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1645 239 );
1646 }
1647  
1648 # Wrap with common middleware
1649 283 ▶ if ( ! $self->config->{'no_default_middleware'} ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->config->{"no_default_middleware"}) 279 4 283
1650 # FixMissingBodyInRedirect
1651 416 $psgi = Plack::Middleware::FixMissingBodyInRedirect->wrap( $psgi );
1652 # Apply Head. After static so a HEAD request on static content DWIM.
1653 416 $psgi = Plack::Middleware::Head->wrap( $psgi );
1654 }
1655  
1656 420 return $psgi;
1657 }
1658  
1659 802 ▶sub dispatch {
Subroutine dispatch: called CC=13 SCAR=25.6
Pod undocumented
1660 802 my $self = shift;
1661 802 my $env = shift;
1662  
1663 802 my $runner = Dancer2::runner();
1664 801 my $request;
1665 802 my $request_built_successfully = eval {
1666 624 ▶ $EVAL_SHIM->(sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
1667 795 ▶ $request = $runner->{'internal_request'} || $self->build_request($env);
Condition100%3/3
$runner->{'internal_request'} || $self->build_request($env)
l!l&&r!l&&!r
717292
MC/DC0%0/2
$runner->{'internal_request'} || $self->build_request($env)
$runner->{'internal_request'} $self->build_request($env)
Truth table66%2/3
A || B
A= $runner->{'internal_request'}B= $self->build_request($env)
ABresult
1X1
011
000
1668 599 });
1669 594 1;
1670 };
1671 # Catch bad content causing deserialization to fail when building the request
1672 599 ▶ if ( ! $request_built_successfully ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($request_built_successfully) 6 796 802
1673 208 my $err = $@;
1674 208 Scalar::Util::weaken(my $app = $self);
1675 return Dancer2::Core::Error->new(
1676 app => $app,
1677 message => $err,
1678 status => 400, # 400 Bad request (dont send again), rather than 500
1679 charset => $self->config->{charset},
1680 208 )->throw;
1681 }
1682  
1683 796 my $cname = $self->session_engine->cookie_name;
1684 796 my $defined_engines = $self->defined_engines;
1685  
1686 DISPATCH:
1687 796 while (1) {
1688 827 my $http_method = lc $request->method;
1689 827 my $path_info = $request->path_info;
1690  
1691 # Add request to app and engines
1692 827 $self->set_request($request, $defined_engines);
1693  
1694 1142 $self->log( core => "looking for $http_method $path_info" );
1695  
1696 ROUTE:
1697 803 foreach my $route ( @{ $self->routes->{$http_method} } ) {
1698 #warn "testing route " . $route->regexp . "\n";
1699 # TODO store in route cache
1700  
1701 # go to the next route if no match
1702 1547 ▶ my $match = $route->match($request)
Branch: 1 branch
BranchTrueFalseTotal
my $match = $route->match($request) or next ROUTE 751 1135 1886
1703 or next ROUTE;
1704  
1705 751 $request->_set_route_params($match);
1706 572 $request->_set_route_parameters($match);
1707 751 $request->_set_route($route);
1708  
1709 # Add session to app *if* we have a session and the request
1710 # has the appropriate cookie header for _this_ app.
1711 751 ▶ if ( my $sess = $runner->{'internal_sessions'}{$cname} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $sess = $runner->{"internal_sessions"}{$cname}) 8 743 751
1712 187 $self->set_session($sess);
1713 }
1714  
1715 # calling the actual route
1716 751 my $response;
1717  
1718 # this is very evil, but allows breaking out of multiple stack
1719 # frames without throwing an exception. Avoiding exceptions means
1720 # a naive eval won't swallow our flow control mechanisms, and
1721 # avoids __DIE__ handlers. It also prevents some cleanup routines
1722 # from working, since they are expecting control to return to them
1723 # after an eval.
1724 DANCER2_CORE_APP_ROUTE_RETURN: {
1725 751 ▶ if (!$self->has_with_return) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->has_with_return) 751 0 751
1726 315 ▶ $self->set_with_return(sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1727 315 $response = shift;
1728 183 ▶ no warnings 'exiting';
Subroutine BEGIN: called CC=1 SCAR=0.0
1729 315 last DANCER2_CORE_APP_ROUTE_RETURN;
1730 751 });
1731 }
1732 572 $response = $self->_dispatch_route($route);
1733 };
1734  
1735 # ensure we clear the with_return handler
1736 572 $self->clear_with_return;
1737  
1738 # handle forward requests
1739 572 ▶ if ( ref $response eq 'Dancer2::Core::Request' ) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $response eq "Dancer2::Core::Request") 50 701 751
1740 # this is actually a request, not response
1741 # however, we need to clean up the request & response
1742 50 $self->clear_request;
1743 50 $self->clear_response;
1744  
1745 # this is in case we're asked for an old-style dispatching
1746 50 ▶ if ( $runner->{'internal_dispatch'} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($runner->{"internal_dispatch"}) 19 31 50
1747 # Get the session object from the app before we clean up
1748 # the request context, so we can propagate this to the
1749 # next dispatch cycle (if required).
1750 $self->_has_session
1751 19 ▶ and $runner->{'internal_sessions'}{$cname} =
Branch: 1 branch
BranchTrueFalseTotal
$self->_has_session and $runner->{"internal_sessions"}{$cname} = $self->session 10 9 19
1752 $self->session;
1753  
1754 19 $runner->{'internal_forward'} = 1;
1755 19 $runner->{'internal_request'} = $response;
1756 198 return $self->response_not_found($request);
1757 }
1758  
1759 47 $request = $response;
1760 47 next DISPATCH;
1761 }
1762  
1763 # from here we assume the response is a Dancer2::Core::Response
1764  
1765 # halted response, don't process further
1766 538 ▶ if ( $response->is_halted ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($response->is_halted) 60 641 701
1767 207 $self->cleanup;
1768 52 delete $runner->{'internal_request'};
1769 52 return $response;
1770 }
1771  
1772 # pass the baton if the response says so...
1773 486 ▶ if ( $response->has_passed ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($response->has_passed) 18 623 641
1774 ## A previous route might have used splat, failed
1775 ## this needs to be cleaned from the request.
1776 exists $request->{_params}{splat}
1777 18 ▶ and delete $request->{_params}{splat};
Branch: 1 branch
BranchTrueFalseTotal
exists $request->{"_params"}{"splat"} and delete $request->{"_params"}{"splat"} 16 2 18
1778  
1779 165 $response->has_passed(0); # clear for the next round
1780  
1781 # clear the content because if you pass it,
1782 # the next route is in charge of catching it
1783 165 $response->clear_content;
1784 165 next ROUTE;
1785 }
1786  
1787 # it's just a regular response
1788 623 $self->execute_hook( 'core.app.after_request', $response );
1789 499 $self->cleanup;
1790 499 delete $runner->{'internal_request'};
1791  
1792 482 return $response;
1793 }
1794  
1795 # we don't actually want to continue the loop
1796 77 last;
1797 }
1798  
1799 # No response! ensure Core::Dispatcher recognizes this failure
1800 # so it can try the next Core::App
1801 # and set the created request so we don't create it again
1802 # (this is important so we don't ignore the previous body)
1803 94 ▶ if ( $runner->{'internal_dispatch'} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($runner->{"internal_dispatch"}) 62 32 94
1804 79 $runner->{'internal_404'} = 1;
1805 79 $runner->{'internal_request'} = $request;
1806 }
1807  
1808 # Render 404 response, cleanup, and return the response.
1809 266 my $response = $self->response_not_found($request);
1810 88 $self->cleanup;
1811 88 return $response;
1812 }
1813  
1814 545 ▶sub build_request {
Subroutine build_request: called CC=3 SCAR=11.0
Pod undocumented
1815 741 my ( $self, $env ) = @_;
1816 545 Scalar::Util::weaken( my $weak_self = $self );
1817  
1818 # If we have an app, send the serialization engine
1819 my $request = Dancer2::Core::Request->new(
1820 env => $env,
1821 is_behind_proxy => $self->settings->{'behind_proxy'} || 0,
1822 179 ▶ uri_for_route => sub { shift; $weak_self->uri_for_route(@_) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1823 strict_utf8 => $self->config->{strict_utf8},
1824  
1825 545 ▶ $self->has_serializer_engine
Branch: 1 branch
BranchTrueFalseTotal
$self->has_serializer_engine ? : 116 626 742
Condition100%2/2
$self->settings->{'behind_proxy'} || 0
l!l
19723
MC/DC100%1/1
$self->settings->{'behind_proxy'} || 0
$self->settings->{'behind_proxy'}
Truth table100%2/2
A
A= $self->settings->{'behind_proxy'}
Aresult
11
00
1826 ? ( serializer => $self->serializer_engine )
1827 : (),
1828 );
1829  
1830 719 return $request;
1831 }
1832  
1833 # Call any before hooks then the matched route.
1834 751 ▶sub _dispatch_route {
Subroutine _dispatch_route: called CC=6 SCAR=17.9
1835 751 my ( $self, $route ) = @_;
1836  
1837 748 local $@;
1838 eval {
1839 747 ▶ $EVAL_SHIM->(sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1840 740 $self->execute_hook( 'core.app.before_request', $self );
1841 573 });
1842 736 1;
1843 573 ▶ } or do {
Branch: 1 branch
BranchTrueFalseTotal
eval { do { &$Dancer2::Core::App::EVAL_SHIM(sub { $self->execute_hook("core.app.before_request", $self); } ); 1 } } or do { my $err = $@ || "Zombie Error"; return $self->response_internal_error($err) } 736 9 745
1844 184 ▶ my $err = $@ || "Zombie Error";
Condition50%1/2
$@ || 'Zombie Error'
l!l
90
MC/DC0%0/1
$@ || 'Zombie Error'
$@
Truth table50%1/2
A
A= $@
Aresult
11
00
1845 9 return $self->response_internal_error($err);
1846 };
1847 735 my $response = $self->response;
1848  
1849 735 ▶ if ( $response->is_halted ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($response->is_halted) 3 733 736
1850 148 return $self->_prep_response( $response );
1851 }
1852  
1853 eval {
1854 563 ▶ $EVAL_SHIM->(sub{ $response = $route->execute($self) });
Subroutine __ANON__: called CC=1 SCAR=0.0
1855 576 1;
1856 563 ▶ } or do {
Branch: 1 branch
BranchTrueFalseTotal
eval { do { &$Dancer2::Core::App::EVAL_SHIM(sub { $response = $route->execute($self); } ); 1 } } or do { my $err = $@ || "Zombie Error"; return $self->response_internal_error($err) } 576 20 596
1857 194 ▶ my $err = $@ || "Zombie Error";
Condition50%1/2
$@ || 'Zombie Error'
l!l
200
MC/DC0%0/1
$@ || 'Zombie Error'
$@
Truth table50%1/2
A
A= $@
Aresult
11
00
1858 190 return $self->response_internal_error($err);
1859 };
1860  
1861 598 return $response;
1862 }
1863  
1864 438 ▶sub _prep_response {
Subroutine _prep_response: called CC=5 SCAR=16.8
1865 600 my ( $self, $response, $content ) = @_;
1866  
1867 # The response object has no back references to the content or app
1868 # Update the default_content_type of the response if any value set in
1869 # config so it can be applied when the response is encoded/returned.
1870 600 my $config = $self->config;
1871 600 ▶ if ( exists $config->{content_type}
Branch: 1 branch
BranchTrueFalseTotal
if (exists $config->{"content_type"} and my $ct = $config->{"content_type"}) 600 0 600
Condition33%1/3
exists $config->{"content_type"} and my $ct = $config->{"content_type"}
!ll&&!rl&&r
00600
MC/DC0%0/2
exists $config->{"content_type"} and my $ct = $config->{"content_type"}
exists $config->{"content_type"} my $ct = $config->{"content_type"}
Truth table33%1/3
A and B
A= exists $config->{"content_type"}B= my $ct = $config->{"content_type"}
ABresult
0X0
100
111
1872 and my $ct = $config->{content_type} ) {
1873 600 $response->default_content_type($ct);
1874 }
1875 exists $config->{charset}
1876 438 ▶ and $response->charset( $config->{charset} );
Branch: 1 branch
BranchTrueFalseTotal
exists $config->{"charset"} and $response->charset($config->{"charset"}) 600 0 600
1877  
1878 # if we were passed any content, set it in the response
1879 438 ▶ defined $content && $response->content($content);
Branch: 1 branch
BranchTrueFalseTotal
defined $content and $response->content($content) 575 25 600
1880 438 return $response;
1881 }
1882  
1883 59 ▶sub response_internal_error {
Subroutine response_internal_error: called CC=1 SCAR=0.0
Pod undocumented
1884 29 my ( $self, $error ) = @_;
1885  
1886 29 $self->execute_hook( 'core.app.route_exception', $self, $error );
1887 28 $self->log( error => "Route exception: $error" );
1888  
1889 58 local $Dancer2::Core::Route::REQUEST = $self->request;
1890 58 local $Dancer2::Core::Route::RESPONSE = $self->response;
1891  
1892 return Dancer2::Core::Error->new(
1893 app => $self,
1894 status => 500,
1895 exception => $error,
1896 charset => $self->config->{charset},
1897 58 )->throw;
1898 }
1899  
1900 105 ▶sub response_not_found {
Subroutine response_not_found: called CC=1 SCAR=0.0
Pod undocumented
1901 123 my ( $self, $request ) = @_;
1902  
1903 123 $self->set_request($request);
1904  
1905 123 local $Dancer2::Core::Route::REQUEST = $self->request;
1906 123 local $Dancer2::Core::Route::RESPONSE = $self->response;
1907  
1908 my $response = Dancer2::Core::Error->new(
1909 app => $self,
1910 status => 404,
1911 message => $request->path,
1912 charset => $self->config->{charset},
1913 105 )->throw;
1914  
1915 105 $self->cleanup;
1916  
1917 103 return $response;
1918 }
1919  
1920 114 ▶sub uri_for_route {
Subroutine uri_for_route: called CC=12 SCAR=24.9
Pod undocumented
1921 24 my ( $self, $route_name, $route_params, $query_params, $dont_escape ) = @_;
1922 24 ▶ my $route = $self->route_names->{$route_name}
Branch: 1 branch
BranchTrueFalseTotal
my $route = $self->route_names->{$route_name} or die "Cannot find route named '${route_name}'" 24 2 26
1923 or die "Cannot find route named '$route_name'";
1924  
1925 12 my $string = $route->spec_route;
1926 24 ▶ is_regexpref($string)
Branch: 1 branch
BranchTrueFalseTotal
is_regexpref($string) and die "uri_for_route() does not support regexp route paths" 1 23 24
1927 and die "uri_for_route() does not support regexp route paths";
1928  
1929 # Convert splat only to the general purpose structure
1930 23 ▶ if ( is_arrayref($route_params) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (is_arrayref($route_params)) 4 19 23
1931 14 $route_params = { 'splat' => $route_params };
1932 }
1933  
1934 # The regexes are taken and altered from:
1935 # Dancer2::Core::Route::_build_regexp_from_string.
1936  
1937 # Replace :foo with arg (route parameters)
1938 # Not a fan of all this regex play to handle typed parameter -- SX
1939 21 my @params = $string =~ m{:([^/.\?]+)}xmsg;
1940  
1941 21 foreach my $param (@params) {
1942 10 $param =~ s{^([^\[]+).*}{$1}xms;
1943 # A defined-but-false value is a legitimate parameter -- 0 is an
1944 # ordinary database ID, list index or page number -- so these are
1945 # tested for definedness and emptiness rather than for truth. The
1946 # empty string is refused because ':param' compiles to ([^/]+),
1947 # which matches at least one character: substituting it would
1948 # produce a URI that cannot match the route it came from.
1949 8 my $value = $route_params->{$param};
1950 20 ▶ if ( !defined $value ) {
Branch: 2 branches
BranchTrueFalseTotal
if (not defined $value) { } 5 17 22
elsif ($value eq '') { } 1 16 17
1951 17 die "Route $route_name uses the parameter '${param}', which was not provided\n";
1952 }
1953 elsif ( $value eq '' ) {
1954 15 die "Route $route_name was given an empty value for the parameter '${param}'\n";
1955 }
1956  
1957 18 $string =~ s!\Q:$param\E(\[[^\]]+\])?!$value!xmsg;
1958 }
1959  
1960 # TODO: Can we cut this down by replacing on the spot?
1961 # I think that will be tricky because we first need all **, then *
1962  
1963 17 $string =~ s!\Q**\E!(?#megasplat)!g;
1964 17 $string =~ s!\*!(?#splat)!g;
1965  
1966 # TODO: Can we cut this down?
1967 9 my @token_or_splat =
1968 $string =~ /\(\?#((?:mega)?splat)\)/g;
1969  
1970 9 my $splat_params = $route_params->{'splat'};
1971 7 ▶ if ($splat_params && @token_or_splat) {
Branch: 1 branch
BranchTrueFalseTotal
if ($splat_params and @token_or_splat) 6 11 17
Condition66%2/3
$splat_params and @token_or_splat
!ll&&!rl&&r
1106
MC/DC50%1/2
$splat_params and @token_or_splat
$splat_params @token_or_splat
Truth table66%2/3
A and B
A= $splat_paramsB= @token_or_splat
ABresult
0X0
100
111
1972 14 ▶ $#{$splat_params} == $#token_or_splat
Branch: 1 branch
BranchTrueFalseTotal
$#{$splat_params;} == $#token_or_splat or die "Mismatch in amount of splat args and splat elements" 4 2 6
1973 or die 'Mismatch in amount of splat args and splat elements';
1974  
1975 4 ▶ for ( my $i = 0; $i < @{$splat_params}; $i++ ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < @{$splat_params;}) 10 4 14
1976 4 ▶ if ( is_arrayref($splat_params->[$i]) ){
Branch: 1 branch
BranchTrueFalseTotal
if (is_arrayref($splat_params->[$i])) { } 4 6 10
1977 6 my $megasplat = join '/', @{ $splat_params->[$i] };
1978 66 $string =~ s{\Q(?#megasplat)\E}{$megasplat};
1979 } else {
1980 66 $string =~ s{\Q(?#splat)\E}{$splat_params->[$i]};
1981 }
1982 }
1983 }
1984  
1985 69 return $self->request->uri_for( $string, $query_params, $dont_escape );
1986 }
1987  
1988 221 1;
1989  
1990 __END__
« blib/lib/Dancer2/Handler/File.pm ↑ Summary lib/Dancer2/ConfigReader/Config/Any.pm »