X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=catagits%2FCatalyst-Runtime.git;a=blobdiff_plain;f=lib%2FCatalyst%2FController.pm;h=68e8b425ff5a0de83c844e0855e4a41bf15bff94;hp=222e269a535059d8a9b9108ff3b3b780c77ea43b;hb=5d8129e9b7bea385dd6fda9b490e7923f61eedd0;hpb=6e58f383a0b7eaabcffdf58be43d807f18aee19c

diff --git a/lib/Catalyst/Controller.pm b/lib/Catalyst/Controller.pm
index 222e269..68e8b42 100644
--- a/lib/Catalyst/Controller.pm
+++ b/lib/Catalyst/Controller.pm
@@ -1,35 +1,48 @@
 package Catalyst::Controller;
 
-use base qw/Catalyst::Component Catalyst::AttrContainer/;
 use Moose;
+use Moose::Util qw/find_meta/;
 
-#Why does the following blow up?
-#extends qw/Catalyst::Component Catalyst::AttrContainer/;
+use namespace::clean -except => 'meta';
 
-has path => (
-             is => 'ro',
-             isa => 'Str',
-             predicate => 'has_path',
-            );
+BEGIN { extends qw/Catalyst::Component MooseX::MethodAttributes::Inheritable/; }
 
-#this are frefixed like this because _namespace clases with something in
-#Catalyst.pm . to be fixed later.
-has _namespace => (
-                   is => 'ro',
-                   isa => 'Str',
-                   init_arg => 'namespace',
-                   predicate => '_has_namespace',
-                 );
-
-__PACKAGE__->mk_accessors( qw/_application/ );
-
-has _application => (is => 'rw');
-sub _app{ shift->_application(@_) } # eww
-
-use Scalar::Util qw/blessed/;
+use MooseX::MethodAttributes;
 use Catalyst::Exception;
 use Catalyst::Utils;
-use Class::Inspector;
+
+with 'Catalyst::Component::ApplicationAttribute';
+
+has path_prefix =>
+    (
+     is => 'rw',
+     isa => 'Str',
+     init_arg => 'path',
+     predicate => 'has_path_prefix',
+    );
+
+has action_namespace =>
+    (
+     is => 'rw',
+     isa => 'Str',
+     init_arg => 'namespace',
+     predicate => 'has_action_namespace',
+    );
+
+has _controller_actions =>
+    (
+     is => 'rw',
+     isa => 'HashRef',
+     init_arg => undef,
+    );
+
+sub BUILD {
+    my ($self, $args) = @_;
+    my $action  = delete $args->{action}  || {};
+    my $actions = delete $args->{actions} || {};
+    my $attr_value = $self->merge_config_hashes($actions, $action);
+    $self->_controller_actions($attr_value);
+}
 
 =head1 NAME
 
@@ -94,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 );
     }
@@ -109,94 +122,110 @@ sub _END : Private {
     return !@{ $c->error };
 }
 
-around new => sub {
-    my $orig = shift;
-    my $self = shift;
-    my $app = $_[0];
-    my $new = $self->$orig(@_);
-    $new->_application( $app );
-    return $new;
-};
-
-
 sub action_for {
     my ( $self, $name ) = @_;
     my $app = ($self->isa('Catalyst') ? $self : $self->_application);
     return $app->dispatcher->get_action($name, $self->action_namespace);
 }
 
-sub 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
+## -- apparently this is all just waiting for app/ctx split
+around action_namespace => sub {
+    my $orig = shift;
     my ( $self, $c ) = @_;
-    unless ( $c ) {
-        $c = ($self->isa('Catalyst') ? $self : $self->_application);
-    }
+
     if( ref($self) ){
-      return $self->_namespace if $self->_has_namespace;
-    } # else { #i think this is hacky and it should work with the else enabled
-      return $self->config->{namespace} if exists $self->config->{namespace};
-    #}
-    return Catalyst::Utils::class2prefix( ref($self) || $self,
-        $c->config->{case_sensitive} )
-      || '';
-}
+        return $self->$orig if $self->has_action_namespace;
+    } else {
+        return $self->config->{namespace} if exists $self->config->{namespace};
+    }
 
-sub path_prefix {
-    my ( $self, $c ) = @_;
-    unless ( $c ) {
-        $c = ($self->isa('Catalyst') ? $self : $self->_application);
+    my $case_s;
+    if( $c ){
+        $case_s = $c->config->{case_sensitive};
+    } else {
+        if ($self->isa('Catalyst')) {
+            $case_s = $self->config->{case_sensitive};
+        } else {
+            if (ref $self) {
+                $case_s = $self->_application->config->{case_sensitive};
+            } else {
+                confess("Can't figure out case_sensitive setting");
+            }
+        }
     }
+
+    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;
     if( ref($self) ){
-      return $self->path if $self->has_path;
-    } # else {
+      return $self->$orig if $self->has_path_prefix;
+    } else {
       return $self->config->{path} if exists $self->config->{path};
-    #}
-    return shift->action_namespace(@_);
+    }
+    my $namespace = $self->action_namespace(@_);
+    $self->$orig($namespace) if ref($self);
+    return $namespace;
+};
+
+sub get_action_methods {
+    my $self = shift;
+    my $meta = find_meta($self);
+    confess("Metaclass for "
+          . ref($meta) . " for "
+          . $meta->name
+          . " cannot support register_actions." )
+      unless $meta->can('get_nearest_methods_with_attributes');
+    my @methods = $meta->get_nearest_methods_with_attributes;
+
+    # actions specified via config are also action_methods
+    push(
+        @methods,
+        map {
+            $meta->get_method($_)
+              || confess( 'Action "' 
+                  . $_
+                  . '" is not available from controller '
+                  . ( ref $self ) )
+          } keys %{ $self->_controller_actions }
+    ) if ( ref $self );
+    return @methods;
 }
 
 
 sub register_actions {
     my ( $self, $c ) = @_;
+    $self->register_action_methods( $c, $self->get_action_methods );
+}
+
+sub register_action_methods {
+    my ( $self, $c, @methods ) = @_;
     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} }
-        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) || [] };
-    }
 
-    # Advanced inheritance support for plugins and the like
-    #to be modified to use meta->superclasses
-    my @action_cache;
-    {
-        no strict 'refs';
-        for my $isa ( @{"$class\::ISA"}, $class ) {
-            push @action_cache, @{ $isa->_action_cache }
-              if $isa->can('_action_cache');
-        }
-    }
-
-    foreach my $cache (@action_cache) {
-        my $code   = $cache->[0];
-        my $method = delete $methods{$code}; # avoid dupe registers
-        next unless $method;
-        my $attrs = $self->_parse_attrs( $c, $method, @{ $cache->[1] } );
+    foreach my $method (@methods) {
+        my $name = $method->name;
+        my $attributes = $method->attributes;
+        my $attrs = $self->_parse_attrs( $c, $name, @{ $attributes } );
         if ( $attrs->{Private} && ( keys %$attrs > 1 ) ) {
             $c->log->debug( 'Bad action definition "'
-                  . join( ' ', @{ $cache->[1] } )
-                  . qq/" for "$class->$method"/ )
+                  . join( ' ', @{ $attributes } )
+                  . qq/" for "$class->$name"/ )
               if $c->debug;
             next;
         }
-        my $reverse = $namespace ? "${namespace}/${method}" : $method;
+        my $reverse = $namespace ? "${namespace}/${name}" : $name;
         my $action = $self->create_action(
-            name       => $method,
-            code       => $code,
+            name       => $name,
+            code       => $method->body,
             reverse    => $reverse,
             namespace  => $namespace,
             class      => $class,
@@ -216,10 +245,6 @@ sub create_action {
                     : $self->_action_class);
 
     Class::MOP::load_class($class);
-    #unless ( Class::Inspector->loaded($class) ) {
-    #    require Class::Inspector->filename($class);
-    #}
-
     return $class->new( \%args );
 }
 
@@ -242,18 +267,24 @@ sub _parse_attrs {
         }
     }
 
-    #this will not work under moose
-    #my $hash = (ref $self ? $self : $self->config); # hate app-is-class
-    #action / actions should be an attribute  of Controller
-    my $hash = $self->config;
-
-    if (exists $hash->{actions} || exists $hash->{action}) {
-      my $a = $hash->{actions} || $hash->{action};
-      %raw_attributes = ((exists $a->{'*'} ? %{$a->{'*'}} : ()),
-                         %raw_attributes,
-                         (exists $a->{$name} ? %{$a->{$name}} : ()));
+    #I know that the original behavior was to ignore action if actions was set
+    # but i actually think this may be a little more sane? we can always remove
+    # the merge behavior quite easily and go back to having actions have
+    # presedence over action by modifying the keys. i honestly think this is
+    # superior while mantaining really high degree of compat
+    my $actions;
+    if( ref($self) ) {
+        $actions = $self->_controller_actions;
+    } else {
+        my $cfg = $self->config;
+        $actions = $self->merge_config_hashes($cfg->{actions}, $cfg->{action});
     }
 
+    %raw_attributes = ((exists $actions->{'*'} ? %{$actions->{'*'}} : ()),
+                       %raw_attributes,
+                       (exists $actions->{$name} ? %{$actions->{$name}} : ()));
+
+
     my %final_attributes;
 
     foreach my $key (keys %raw_attributes) {
@@ -263,8 +294,8 @@ sub _parse_attrs {
         foreach my $value (ref($raw) eq 'ARRAY' ? @$raw : $raw) {
 
             my $meth = "_parse_${key}_attr";
-            if ( $self->can($meth) ) {
-                ( $key, $value ) = $self->$meth( $c, $name, $value );
+            if ( my $code = $self->can($meth) ) {
+                ( $key, $value ) = $self->$code( $c, $name, $value );
             }
             push( @{ $final_attributes{$key} }, $value );
         }
@@ -289,7 +320,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 );
     }
@@ -311,16 +342,56 @@ 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/^\+// ) {
-      $value = join('::', $self->_action_class, $value );
-    }
+    my $appname = $self->_application;
+    $value = Catalyst::Utils::resolve_namespace($appname . '::Action', $self->_action_class, $value);
     return ( 'ActionClass', $value );
 }
 
@@ -333,6 +404,8 @@ sub _parse_MyAction_attr {
     return ( 'ActionClass', $value );
 }
 
+__PACKAGE__->meta->make_immutable;
+
 1;
 
 __END__
@@ -357,22 +430,16 @@ Sets 'path_prefix', as described below.
 
 =head1 METHODS
 
-=head2 $class->new($app, @args)
+=head2 BUILDARGS ($app, @args)
 
-Proxies through to NEXT::new and stashes the application instance as
-$self->_application.
+From L<Catalyst::Component::ApplicationAttribute>, stashes the application
+instance as $self->_application.
 
 =head2 $self->action_for('name')
 
 Returns the Catalyst::Action object (if any) for a given method name
 in this component.
 
-=head2 $self->register_actions($c)
-
-Finds all applicable actions for this component, creates
-Catalyst::Action objects (using $self->create_action) for them and
-registers them with $c->dispatcher.
-
 =head2 $self->action_namespace($c)
 
 Returns the private namespace for actions in this component. Defaults
@@ -383,27 +450,41 @@ 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->register_actions($c)
+
+Finds all applicable actions for this component, creates
+Catalyst::Action objects (using $self->create_action) for them and
+registers them with $c->dispatcher.
+
+=head2 $self->get_action_methods()
+
+Returns a list of L<Moose::Meta::Method> objects, doing the
+L<MooseX::MethodAttributes::Role::Meta::Method> role, which are the set of
+action methods for this package.
+
+=head2 $self->register_action_methods($c, @methods)
+
+Creates action objects for a set of action methods using C< create_action >,
+and registers them with the dispatcher.
+
 =head2 $self->create_action(%args)
 
 Called with a hash of data to be use for construction of a new
 Catalyst::Action (or appropriate sub/alternative class) object.
 
-Primarily designed for the use of register_actions.
-
 =head2 $self->_application
 
 =head2 $self->_app
 
 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