package Catalyst;
-use Class::C3;
+use MRO::Compat;
+use mro 'c3';
use Moose;
extends 'Catalyst::Component';
use bytes;
# callers @ISA.
return unless $class eq 'Catalyst';
- my $caller = caller(0);
+ my $caller = caller();
+ return if $caller eq 'main';
+ my $meta = Moose::Meta::Class->initialize($caller);
+ #Moose->import({ into => $caller }); #do we want to do this?
- #why does called have to ISA Catalyst and ISA Controller ?
- #Convert test suite to not use the behavior where Myapp ISA Controller
- # after that is done we can eliminate that little mess.
unless ( $caller->isa('Catalyst') ) {
- no strict 'refs';
- if( $caller->can('meta') ){
- my @superclasses = ($caller->meta->superclasses, $class, 'Catalyst::Controller');
- #my @superclasses = ($caller->meta->superclasses, $class);
- $caller->meta->superclasses(@superclasses);
- } else {
- push @{"$caller\::ISA"}, $class, 'Catalyst::Controller';
- #push @{"$caller\::ISA"}, $class;
- }
+ my @superclasses = ($meta->superclasses, $class, 'Catalyst::Controller');
+ $meta->superclasses(@superclasses);
+ }
+ unless( $meta->has_method('meta') ){
+ $meta->add_method(meta => sub { Moose::Meta::Class->initialize("${caller}") } );
}
$caller->arguments( [@arguments] );
sub setup {
my ( $class, @arguments ) = @_;
-
+ Class::C3::initialize;
$class->log->warn("Running setup twice is not a good idea.")
if ( $class->setup_finished );
}
# Add our self to components, since we are also a component
- $class->components->{$class} = $class;
+ if( $class->isa('Catalyst::Controller') ){
+ $class->components->{$class} = $class;
+ }
$class->setup_actions;
$class->log->_flush() if $class->log->can('_flush');
$class->setup_finished(1);
+ Class::C3::initialize;
}
=head2 $c->uri_for( $path, @args?, \%query_values? )
$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$/ ) {
Catalyst::Exception->throw(
message =>
qq/Couldn't instantiate component "$component", "COMPONENT() didn't return an object-like value"/
- ) unless eval { $instance->can( 'can' ) };
+ ) unless blessed($instance);
return $instance;
}
if ( $ENV{MOD_PERL} ) {
# create the apache method
- {
- no strict 'refs';
- *{"$class\::apache"} = sub { shift->engine->apache };
- }
+ $class->meta->add_method('apache' => sub { shift->engine->apache });
my ( $software, $version ) =
$ENV{MOD_PERL} =~ /^(\S+)\/(\d+(?:[\.\_]\d+)+)/;
my $env_debug = Catalyst::Utils::env_value( $class, 'DEBUG' );
if ( defined($env_debug) ? $env_debug : $debug ) {
- no strict 'refs';
- #Moose todo: dying to be made a bool attribute
- *{"$class\::debug"} = sub { 1 };
+ $class->meta->add_method('debug' => sub { 1 });
$class->log->debug('Debug messages enabled');
}
}
my $env = Catalyst::Utils::env_value( $class, 'STATS' );
if ( defined($env) ? $env : ($stats || $class->debug ) ) {
- no strict 'refs';
- #Moose todo: dying to be made a bool attribute
- *{"$class\::use_stats"} = sub { 1 };
+ $class->meta->add_method('use_stats' => sub { 1 });
$class->log->debug('Statistics enabled');
}
}