Remove use of overload

[catagits/Catalyst-Runtime.git] / lib / Catalyst.pm

diff --git a/lib/Catalyst.pm b/lib/Catalyst.pm
index 37425b1..e22ff81 100644 (file)
--- a/lib/Catalyst.pm
+++ b/lib/Catalyst.pm
@@ -1,5 +1,6 @@
 package Catalyst;
 
+use Class::C3;
 use Moose;
 extends 'Catalyst::Component';
 use bytes;
@@ -39,13 +40,12 @@ has request => (is => 'rw', default => sub { $_[0]->request_class->new({}) }, re
 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 || [] }; }
-
-# Laziness++
-*comp = \&component;
+sub comp { shift->component(@_) }
 
 sub req {
     # carp "the use of req() is deprecated in favour of request()";
@@ -57,7 +57,7 @@ sub res {
 }
 
 # For backwards compatibility
-*finalize_output = \&finalize_body;
+sub finalize_output { shift->finalize_body(@_) };
 
 # For statistics
 our $COUNT     = 1;
@@ -379,20 +379,20 @@ Catalyst).
 
 =cut
 
-around stash => sub {
-    my $orig = shift;
+sub stash {
     my $c = shift;
-
-    my $orig_stash = $c->$orig();
     if (@_) {
         my $stash = @_ > 1 ? {@_} : $_[0];
         croak('stash takes a hash or hashref') unless ref $stash;
         foreach my $key ( keys %$stash ) {
-            $orig_stash->{$key} = $stash->{$key};
+            #shouldn't we hold this in a var and save ourselves the subcall?
+            $c->next::method->{$key} = $stash->{$key};
         }
     }
-    return $orig_stash;
-};
+
+    return $c->next::method;
+}
+
 
 =head2 $c->error
 
@@ -704,15 +704,14 @@ L<Catalyst::Plugin::ConfigLoader>.
 
 =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
 
@@ -1235,9 +1234,9 @@ sub execute {
     $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);
@@ -1248,7 +1247,7 @@ sub execute {
 
     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;
     
@@ -1277,9 +1276,10 @@ sub _stats_start_execute {
     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
@@ -1298,7 +1298,7 @@ sub _stats_start_execute {
         }
     }
 
-    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$/ ) {