mro compat stuff

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

diff --git a/lib/Catalyst/Controller.pm b/lib/Catalyst/Controller.pm
index 2e58312..ba7d296 100644 (file)
--- a/lib/Catalyst/Controller.pm
+++ b/lib/Catalyst/Controller.pm
@@ -1,6 +1,8 @@
 package Catalyst::Controller;
 
 #switch to BEGIN { extends qw/ ... /; } ?
+use MRO::Compat;
+use mro 'c3';
 use base qw/Catalyst::Component Catalyst::AttrContainer/;
 use Moose;
 
@@ -11,7 +13,7 @@ use Class::Inspector;
 
 has path_prefix =>
     (
-     is => 'ro',
+     is => 'rw',
      isa => 'Str',
      init_arg => 'path',
      predicate => 'has_path_prefix',
@@ -19,7 +21,7 @@ has path_prefix =>
 
 has action_namespace =>
     (
-     is => 'ro',
+     is => 'rw',
      isa => 'Str',
      init_arg => 'namespace',
      predicate => 'has_action_namespace',
@@ -34,7 +36,7 @@ has actions =>
 
 # isa => 'ClassName|Catalyst' ?
 has _application => (is => 'rw');
-sub _app{ shift->_application(@_) } # eww
+sub _app{ shift->_application(@_) } 
 
 sub BUILD {
     my ($self, $args) = @_;
@@ -122,14 +124,13 @@ sub _END : Private {
     return !@{ $c->error };
 }
 
-around new => sub {
-    my $orig = shift;
+sub new {
     my $self = shift;
     my $app = $_[0];
-    my $new = $self->$orig(@_);
+    my $new = $self->next::method(@_);
     $new->_application( $app );
     return $new;
-};
+}
 
 sub action_for {
     my ( $self, $name ) = @_;
@@ -137,18 +138,26 @@ sub action_for {
     return $app->dispatcher->get_action($name, $self->action_namespace);
 }
 
+#my opinion is that this whole sub really should be a builder method, not 
+#something that happens on every call. Anyone else disagree?? -- groditi
+
+#we are wrapping the accessor, so just uyse a modifier since a normal sub would
+#just be overridden by the generated moose method 
 around action_namespace => sub {
-    my ( $orig, $self, $c ) = @_;
+    my $orig = shift;
+    my ( $self, $c ) = @_;
 
     if( ref($self) ){
         return $self->$orig if $self->has_action_namespace;
-    } else {
+    } else { 
+       warn "action_namespace called as class method";
+       # if the following won't change at runtime it should be lazy_building thing
         return $self->config->{namespace} if exists $self->config->{namespace};
     }
 
     #the following looks like a possible target for a default setting. i am not
     #making the below the builder because i don't know if $c will vary from
-    #call to call, which would affect case sensitivitysettings -- groditi
+    #call to call, which would affect case sensitivity settings -- groditi
     my $case_s;
     if( $c ){
         $case_s = $c->config->{case_sensitive};
@@ -164,10 +173,12 @@ around action_namespace => sub {
         }
     }
 
-    return Catalyst::Utils::class2prefix(ref($self) || $self, $case_s) || '';
+    my $namespace = Catalyst::Utils::class2prefix(ref($self) || $self, $case_s) || '';
+    $self->$orig($namespace) if ref($self);
+    return $namespace;
 };
 
-
+#Once again, this is probably better written as a builder method
 around path_prefix => sub {
     my $orig = shift;
     my $self = shift;
@@ -176,7 +187,9 @@ around path_prefix => sub {
     } else {
       return $self->config->{path} if exists $self->config->{path};
     }
-    return $self->action_namespace(@_);
+    my $namespace = $self->action_namespace(@_);
+    $self->$orig($namespace) if ref($self);
+    return $namespace;
 };
 
 
@@ -185,26 +198,18 @@ sub register_actions {
     my $class = ref $self || $self;
     #this is still not correct for some reason.
     my $namespace = $self->action_namespace($c);
-    my %methods;
-    if( $self->can('meta') ){
-      my $meta = $self->meta;
-      %methods = map{ $_->{code}->body => $_->{name} }
+    my $meta = $self->meta;
+    my %methods = map{ $_->{code}->body => $_->{name} }
         grep {$_->{class} ne 'Moose::Object'} #ignore Moose::Object methods
-          $meta->compute_all_applicable_methods;
-    } else { #until we are sure there's no moose stuff left...
-      $methods{ $self->can($_) } = $_
-        for @{ Class::Inspector->methods($class) || [] };
-    }
+            $meta->compute_all_applicable_methods;
+
 
     # Advanced inheritance support for plugins and the like
-    #to be modified to use meta->superclasses
     #moose todo: migrate to eliminate CDI compat
     my @action_cache;
-    {
-        no strict 'refs';
-        for my $isa ( @{"$class\::ISA"}, $class ) {
-            push @action_cache, @{ $isa->_action_cache }
-              if $isa->can('_action_cache');
+    for my $isa ( $meta->superclasses, $class ) {
+        if(my $coderef = $isa->can('_action_cache')){
+            push(@action_cache, @{ $isa->$coderef });
         }
     }
 
@@ -362,6 +367,8 @@ sub _parse_MyAction_attr {
     return ( 'ActionClass', $value );
 }
 
+no Moose;
+
 1;
 
 __END__