X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FController.pm;h=17b5c529caaa85774f406668398f627a4f5162b6;hb=2f3812528068bc1d9f7840067f0c03d36cd47e6d;hp=29ffc8127304dfee5c24842fadd332e6ce099c9d;hpb=0fc2d522eec43202c21e9f0062e43f10db4d9008;p=catagits%2FCatalyst-Runtime.git

diff --git a/lib/Catalyst/Controller.pm b/lib/Catalyst/Controller.pm
index 29ffc81..17b5c52 100644
--- a/lib/Catalyst/Controller.pm
+++ b/lib/Catalyst/Controller.pm
@@ -1,7 +1,6 @@
 package Catalyst::Controller;
 
 #switch to BEGIN { extends qw/ ... /; } ?
-use Class::C3;
 use base qw/Catalyst::Component Catalyst::AttrContainer/;
 use Moose;
 
@@ -12,7 +11,7 @@ use Class::Inspector;
 
 has path_prefix =>
     (
-     is => 'ro',
+     is => 'rw',
      isa => 'Str',
      init_arg => 'path',
      predicate => 'has_path_prefix',
@@ -20,7 +19,7 @@ has path_prefix =>
 
 has action_namespace =>
     (
-     is => 'ro',
+     is => 'rw',
      isa => 'Str',
      init_arg => 'namespace',
      predicate => 'has_action_namespace',
@@ -108,7 +107,7 @@ sub _ACTION : Private {
     my ( $self, $c ) = @_;
     if (   ref $c->action
         && $c->action->can('execute')
-        && $c->req->action )
+        && defined $c->req->action )
     {
         $c->action->dispatch( $c );
     }
@@ -123,13 +122,14 @@ sub _END : Private {
     return !@{ $c->error };
 }
 
-sub new {
+around new => sub {
+    my $orig = shift;
     my $self = shift;
     my $app = $_[0];
-    my $new = $self->next::method(@_);
+    my $new = $self->$orig(@_);
     $new->_application( $app );
     return $new;
-}
+};
 
 sub action_for {
     my ( $self, $name ) = @_;
@@ -139,23 +139,17 @@ sub action_for {
 
 #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 
+## -- apparently this is all just waiting for app/ctx split
 around action_namespace => sub {
     my $orig = shift;
     my ( $self, $c ) = @_;
 
     if( ref($self) ){
         return $self->$orig if $self->has_action_namespace;
-    } else { 
-        # if the following won't change at runtime it should be lazy_building thing
+    } else {
         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 sensitivity settings -- groditi
     my $case_s;
     if( $c ){
         $case_s = $c->config->{case_sensitive};
@@ -171,7 +165,9 @@ 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
@@ -183,7 +179,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;
 };
 
 
@@ -192,26 +190,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 });
         }
     }
 
@@ -325,7 +315,7 @@ sub _parse_Relative_attr { shift->_parse_Local_attr(@_); }
 
 sub _parse_Path_attr {
     my ( $self, $c, $name, $value ) = @_;
-    $value ||= '';
+    $value = '' if !defined $value;
     if ( $value =~ m!^/! ) {
         return ( 'Path', $value );
     }
@@ -347,11 +337,52 @@ sub _parse_Regexp_attr { shift->_parse_Regex_attr(@_); }
 sub _parse_LocalRegex_attr {
     my ( $self, $c, $name, $value ) = @_;
     unless ( $value =~ s/^\^// ) { $value = "(?:.*?)$value"; }
-    return ( 'Regex', '^' . $self->path_prefix($c) . "/${value}" );
+
+    my $prefix = $self->path_prefix( $c );
+    $prefix .= '/' if length( $prefix );
+   
+    return ( 'Regex', "^${prefix}${value}" );
 }
 
 sub _parse_LocalRegexp_attr { shift->_parse_LocalRegex_attr(@_); }
 
+sub _parse_Chained_attr {
+    my ($self, $c, $name, $value) = @_;
+
+    if (defined($value) && length($value)) {
+        if ($value eq '.') {
+            $value = '/'.$self->action_namespace($c);
+        } elsif (my ($rel, $rest) = $value =~ /^((?:\.{2}\/)+)(.*)$/) {
+            my @parts = split '/', $self->action_namespace($c);
+            my @levels = split '/', $rel;
+
+            $value = '/'.join('/', @parts[0 .. $#parts - @levels], $rest);
+        } elsif ($value !~ m/^\//) {
+            my $action_ns = $self->action_namespace($c);
+
+            if ($action_ns) {
+                $value = '/'.join('/', $action_ns, $value);
+            } else {
+                $value = '/'.$value; # special case namespace '' (root)
+            }
+        }
+    } else {
+        $value = '/'
+    }
+
+    return Chained => $value;
+}
+
+sub _parse_ChainedParent_attr {
+    my ($self, $c, $name, $value) = @_;
+    return $self->_parse_Chained_attr($c, $name, '../'.$name);
+}
+
+sub _parse_PathPrefix_attr {
+    my $self = shift;
+    return PathPart => $self->path_prefix;
+}
+
 sub _parse_ActionClass_attr {
     my ( $self, $c, $name, $value ) = @_;
     unless ( $value =~ s/^\+// ) {
@@ -371,6 +402,8 @@ sub _parse_MyAction_attr {
 
 no Moose;
 
+__PACKAGE__->meta->make_immutable;
+
 1;
 
 __END__
@@ -421,8 +454,8 @@ overridden from the "namespace" config key.
 
 =head2 $self->path_prefix($c)
 
-Returns the default path prefix for :Local, :LocalRegex and relative
-:Path actions in this component. Defaults to the action_namespace or
+Returns the default path prefix for :PathPrefix, :Local, :LocalRegex and
+relative :Path actions in this component. Defaults to the action_namespace or
 can be overridden from the "path" config key.
 
 =head2 $self->create_action(%args)
@@ -438,10 +471,9 @@ Primarily designed for the use of register_actions.
 
 Returns the application instance stored by C<new()>
 
-=head1 AUTHOR
+=head1 AUTHORS
 
-Sebastian Riedel, C<sri@oook.de>
-Marcus Ramberg C<mramberg@cpan.org>
+Catalyst Contributors, see Catalyst.pm
 
 =head1 COPYRIGHT