package Catalyst;
+use Class::C3;
use Moose;
extends 'Catalyst::Component';
use bytes;
BEGIN { require 5.008001; }
-has stack => (is => 'rw');
-has stash => (is => 'rw');
-has state => (is => 'rw');
+has stack => (is => 'rw', default => sub { [] });
+has stash => (is => 'rw', default => sub { {} });
+has state => (is => 'rw', default => 0);
has stats => (is => 'rw');
has action => (is => 'rw');
-has counter => (is => 'rw');
-has request => (is => 'rw');
-has response => (is => 'rw');
+has counter => (is => 'rw', default => sub { {} });
+has request => (is => 'rw', default => sub { $_[0]->request_class->new({}) }, required => 1, lazy => 1);
+has response => (is => 'rw', default => sub { $_[0]->response_class->new({}) }, required => 1, lazy => 1);
has namespace => (is => 'rw');
+no Moose;
attributes->import( __PACKAGE__, \&namespace, 'lvalue' );
sub depth { scalar @{ shift->stack || [] }; }
+sub comp { shift->component(@_) }
-# Laziness++
-*comp = \&component;
-*req = \&request;
-*res = \&response;
+sub req {
+ # carp "the use of req() is deprecated in favour of request()";
+ my $self = shift; return $self->request(@_);
+}
+sub res {
+ # carp "the use of res() is deprecated in favour of response()";
+ my $self = shift; return $self->response(@_);
+}
# For backwards compatibility
-*finalize_output = \&finalize_body;
+sub finalize_output { shift->finalize_body(@_) };
# For statistics
our $COUNT = 1;
=cut
-sub forward { my $c = shift; $c->dispatcher->forward( $c, @_ ) }
+sub forward { my $c = shift; no warnings 'recursion'; $c->dispatcher->forward( $c, @_ ) }
=head2 $c->detach( $action [, \@arguments ] )
=cut
-around stash => sub {
- my $orig = shift;
+sub stash {
my $c = shift;
if (@_) {
my $stash = @_ > 1 ? {@_} : $_[0];
croak('stash takes a hash or hashref') unless ref $stash;
foreach my $key ( keys %$stash ) {
- $c->$orig()->{$key} = $stash->{$key};
+ #shouldn't we hold this in a var and save ourselves the subcall?
+ $c->next::method->{$key} = $stash->{$key};
}
}
- return $c->$orig();
-};
+
+ return $c->next::method;
+}
+
=head2 $c->error
=cut
-around config => sub {
- my $orig = shift;
+sub config {
my $c = shift;
$c->log->warn("Setting config after setup has been run is not a good idea.")
if ( @_ and $c->setup_finished );
- $c->$orig(@_);
-};
+ $c->next::method(@_);
+}
=head2 $c->log
$c->state(0);
if ( $c->depth >= $RECURSION ) {
- my $action = "$code";
+ my $action = $code->reverse();
$action = "/$action" unless $action =~ /->/;
- my $error = qq/Deep recursion detected calling "$action"/;
+ my $error = qq/Deep recursion detected calling "${action}"/;
$c->log->error($error);
$c->error($error);
$c->state(0);
push( @{ $c->stack }, $code );
- eval { $c->state( &$code( $class, $c, @{ $c->req->args } ) || 0 ) };
+ eval { $c->state( $code->execute( $class, $c, @{ $c->req->args } ) || 0 ) };
$c->_stats_finish_execute( $stats_info ) if $c->use_stats and $stats_info;
return if ( ( $code->name =~ /^_.*/ )
&& ( !$c->config->{show_internal_actions} ) );
- $c->counter->{"$code"}++;
+ my $action_name = $code->reverse();
+ $c->counter->{$action_name}++;
- my $action = "$code";
+ my $action = $action_name;
$action = "/$action" unless $action =~ /->/;
# determine if the call was the result of a forward
}
}
- my $uid = "$code" . $c->counter->{"$code"};
+ my $uid = $action_name . $c->counter->{$action_name};
# is this a root-level call or a forwarded call?
if ( $callsub =~ /forward$/ ) {
my $response = $c->response; #accessor calls can add up?
- # Moose TODO: Maybe this should be an attribute too?
# Check if we already finalized headers
- return if $response->{_finalized_headers};
+ return if $response->finalized_headers;
# Handle redirects
if ( my $location = $response->redirect ) {
$c->engine->finalize_headers( $c, @_ );
# Done
- $response->{_finalized_headers} = 1;
+ $response->finalized_headers(1);
}
=head2 $c->finalize_output
}
$COUNT++;
- #todo: reuse coderef from can
- $class->log->_flush() if $class->log->can('_flush');
+
+ if(my $coderef = $class->log->can('_flush')){
+ $class->log->$coderef();
+ }
return $status;
}
sub prepare {
my ( $class, @arguments ) = @_;
- #moose todo: context_class as attr with default
+ # XXX
+ # After the app/ctxt split, this should become an attribute based on something passed
+ # into the application.
$class->context_class( ref $class || $class ) unless $class->context_class;
- #Moose TODO: if we make empty containers the defaults then that can be
- #handled by the context class itself instead of having this here
- my $c = $class->context_class->new(
- {
- counter => {},
- stack => [],
- request => $class->request_class->new(
- {
- arguments => [],
- body_parameters => {},
- cookies => {},
- headers => HTTP::Headers->new,
- parameters => {},
- query_parameters => {},
- secure => 0,
- captures => [],
- uploads => {}
- }
- ),
- response => $class->response_class->new(
- {
- body => '',
- cookies => {},
- headers => HTTP::Headers->new(),
- status => 200
- }
- ),
- stash => {},
- state => 0
- }
- );
+
+ my $c = $class->context_class->new({});
+
+ # For on-demand data
+ $c->request->_context($c);
+ $c->response->_context($c);
#surely this is not the most efficient way to do things...
$c->stats($class->stats_class->new)->enable($c->use_stats);
$c->res->headers->header( 'X-Catalyst' => $Catalyst::VERSION );
}
- # For on-demand data
- $c->request->_context($c);
- $c->response->_context($c);
-
#XXX reuse coderef from can
# Allow engine to direct the prepare flow (for POE)
if ( $c->engine->can('prepare') ) {
projects / catagits/Catalyst-Runtime.git / blobdiff