Dancer2
view release on metacpan or search on metacpan
lib/Dancer2/Core/App.pm view on Meta::CPAN
defined $value or $value = $config->{'session'} || 'simple';
is_ref($value) and return $value;
is_module_name($value)
or croak "Cannot load session engine '$value': illegal module name";
my $engine_options =
$self->_get_config_for_engine( session => $value, $config );
Scalar::Util::weaken( my $weak_self = $self );
# Note that engine options will replace the default session_dir (if provided).
return $self->_factory->create(
session => $value,
session_dir => path( $self->config->{appdir}, 'sessions' ),
%{$engine_options},
postponed_hooks => $self->postponed_hooks,
log_cb => sub { $weak_self->log(@_) },
);
lib/Dancer2/Core/App.pm view on Meta::CPAN
my $engine_options =
$self->_get_config_for_engine( template => $value, $config );
my $engine_attrs = {
config => $engine_options,
layout => $config->{layout},
layout_dir => ( $config->{layout_dir} || 'layouts' ),
views => $config->{views},
};
Scalar::Util::weaken( my $weak_self = $self );
return $self->_factory->create(
template => $value,
%{$engine_attrs},
postponed_hooks => $self->postponed_hooks,
log_cb => sub { $weak_self->log(@_) },
);
}
lib/Dancer2/Core/App.pm view on Meta::CPAN
defined $config or $config = $self->config;
defined $value or $value = $config->{serializer};
defined $value or return;
is_ref($value) and return $value;
my $engine_options =
$self->_get_config_for_engine( serializer => $value, $config );
Scalar::Util::weaken( my $weak_self = $self );
return $self->_factory->create(
serializer => $value,
config => $engine_options,
postponed_hooks => $self->postponed_hooks,
log_cb => sub { $weak_self->log(@_) },
);
}
lib/Dancer2/Core/App.pm view on Meta::CPAN
predicate => 'has_request',
);
sub set_request {
my ($self, $request, $defined_engines) = @_;
# typically this is passed in as an optimization within the
# dispatch loop but may be called elsewhere
$defined_engines ||= $self->defined_engines;
# populate request in app and all engines
$self->_set_request($request);
Scalar::Util::weaken( my $weak_request = $request );
$_->set_request( $weak_request ) for @{$defined_engines};
}
has response => (
is => 'ro',
isa => InstanceOf['Dancer2::Core::Response'],
lazy => 1,
writer => 'set_response',
clearer => 'clear_response',
builder => '_build_response',
lib/Dancer2/Core/App.pm view on Meta::CPAN
],
};
}
sub _init_hooks {
my $self = shift;
# Hook to flush the session at the end of the request,
# this way, we're sure we flush only once per request
#
# Note: we create a weakened copy $self
# before closing over the weakened copy
# to avoid circular memory refs.
Scalar::Util::weaken(my $app = $self);
$self->add_hook(
Dancer2::Core::Hook->new(
name => 'core.app.after_request',
code => sub {
my $response = $Dancer2::Core::Route::RESPONSE;
# make sure an engine is defined, if not, nothing to do
my $engine = $app->session_engine;
defined $engine or return;
lib/Dancer2/Core/App.pm view on Meta::CPAN
my $env = $self->request->env;
if ( $env->{'psgi.streaming'} && $use_streaming ) {
my $cb = sub {
my $responder = $Dancer2::Core::Route::RESPONDER;
my $res = $Dancer2::Core::Route::RESPONSE;
return $responder->(
[ $res->status, $res->headers_to_array, $fh ]
);
};
Scalar::Util::weaken( my $weak_self = $self );
$response = Dancer2::Core::Response::Delayed->new(
error_cb => sub { $weak_self->logger_engine->log( warning => @_ ) },
cb => $cb,
request => $Dancer2::Core::Route::REQUEST,
response => $Dancer2::Core::Route::RESPONSE,
);
}
else {
$response = $self->response;
lib/Dancer2/Core/App.pm view on Meta::CPAN
$handler_code->register($self);
}
}
sub compile_hooks {
my ($self) = @_;
for my $position ( $self->supported_hooks ) {
my $compiled_hooks = [];
for my $hook ( @{ $self->hooks->{$position} } ) {
Scalar::Util::weaken( my $app = $self );
my $compiled = sub {
# don't run the filter if halt has been used
$Dancer2::Core::Route::RESPONSE &&
$Dancer2::Core::Route::RESPONSE->is_halted
and return;
eval { $EVAL_SHIM->($hook,@_); 1; }
or do {
my $err = $@ || "Zombie Error";
$app->cleanup;
lib/Dancer2/Core/App.pm view on Meta::CPAN
my $request;
my $request_built_successfully = eval {
$EVAL_SHIM->(sub {
$request = $runner->{'internal_request'} || $self->build_request($env);
});
1;
};
# Catch bad content causing deserialization to fail when building the request
if ( ! $request_built_successfully ) {
my $err = $@;
Scalar::Util::weaken(my $app = $self);
return Dancer2::Core::Error->new(
app => $app,
message => $err,
status => 400, # 400 Bad request (dont send again), rather than 500
)->throw;
}
my $cname = $self->session_engine->cookie_name;
my $defined_engines = $self->defined_engines;
lib/Dancer2/Core/App.pm view on Meta::CPAN
}
# Render 404 response, cleanup, and return the response.
my $response = $self->response_not_found($request);
$self->cleanup;
return $response;
}
sub build_request {
my ( $self, $env ) = @_;
Scalar::Util::weaken( my $weak_self = $self );
# If we have an app, send the serialization engine
my $request = Dancer2::Core::Request->new(
env => $env,
is_behind_proxy => $self->settings->{'behind_proxy'} || 0,
uri_for_route => sub { shift; $weak_self->uri_for_route(@_) },
$self->has_serializer_engine
? ( serializer => $self->serializer_engine )
: (),
lib/Dancer2/Core/Request.pm view on Meta::CPAN
# "works".
my $serializer_fail;
my $serializer_log_cb = $serializer->log_cb;
local $serializer->{log_cb} = sub {
$serializer_fail = $_[1];
$serializer_log_cb->(@_);
};
# work-around to resolve a chicken-and-egg issue when instantiating a
# request object; the serializer needs that request object to deserialize
# the body params.
Scalar::Util::weaken( my $request = $self );
$self->serializer->has_request || $self->serializer->set_request($request);
my $data = $serializer->deserialize($body);
die $serializer_fail if $serializer_fail;
# Set _body_params directly rather than using the setter. Deserializiation
# returns characters and skipping the decode op in the setter ensures
# that numerical data "stays" numerical; decoding an SV that is an IV
# converts that to a PVIV. Some serializers are picky (JSON)..
$self->{_body_params} = $data;
lib/Dancer2/Plugin.pm view on Meta::CPAN
}
}
{
# get the reference
my ($plugin_addr) = "$plugin" =~ $REF_ADDR_REGEX;
$instances{$plugin_addr}{'config'} = sub { $plugin->config };
$instances{$plugin_addr}{'app'} = $plugin->app;
Scalar::Util::weaken( $instances{$plugin_addr}{'app'} );
## no critic
no strict 'refs';
# we used a forward declaration
# so the compiled form "plugin_setting;" can be overridden
# with this implementation,
# which works on runtime ("plugin_setting()")
# we can't use can() here because the forward declaration will
# create a CODE stub
lib/Dancer2/Template/TemplateToolkit.pm view on Meta::CPAN
%{ $self->config },
);
my $start_tag = $self->config->{'start_tag'};
my $stop_tag = $self->config->{'stop_tag'} || $self->config->{end_tag};
$tt_config{'START_TAG'} = $start_tag
if defined $start_tag && $start_tag ne '[%';
$tt_config{'END_TAG'} = $stop_tag
if defined $stop_tag && $stop_tag ne '%]';
Scalar::Util::weaken( my $ttt = $self );
my $include_path = $self->config->{include_path};
$tt_config{'INCLUDE_PATH'} ||= [
( defined $include_path ? $include_path : () ),
sub { [ $ttt->views ] },
];
my $tt = Template->new(%tt_config);
$Template::Stash::PRIVATE = undef if $self->config->{show_private_variables};
return $tt;
}
( run in 0.405 second using v1.01-cache-2.11-cpan-65fba6d93b7 )