package Catalyst::Controller;
-#switch to BEGIN { extends qw/ ... /; } ?
-use base qw/Catalyst::Component Catalyst::AttrContainer/;
use Moose;
+use Moose::Util qw/find_meta/;
-use Scalar::Util qw/blessed/;
+use namespace::clean -except => 'meta';
+
+BEGIN { extends qw/Catalyst::Component MooseX::MethodAttributes::Inheritable/; }
+
+use MooseX::MethodAttributes;
use Catalyst::Exception;
use Catalyst::Utils;
-use Class::Inspector;
+
+with 'Catalyst::Component::ApplicationAttribute';
has path_prefix =>
(
predicate => 'has_action_namespace',
);
-has actions =>
+has _controller_actions =>
(
is => 'rw',
isa => 'HashRef',
init_arg => undef,
);
-# isa => 'ClassName|Catalyst' ?
-has _application => (is => 'rw');
-sub _app{ shift->_application(@_) }
-
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->actions($attr_value);
+ $self->_controller_actions($attr_value);
}
=head1 NAME
package MyApp::Controller::Search
use base qw/Catalyst::Controller/;
- sub foo : Local {
+ sub foo : Local {
my ($self,$c,@args) = @_;
- ...
+ ...
} # Dispatches to /search/foo
=head1 DESCRIPTION
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);
}
-#my opinion is that this whole sub really should be a builder method, not
+#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 {
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->find_method_by_name($_)
+ || 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 $meta = $self->meta;
- my %methods = map { $_->body => $_->name }
- grep { $_->package_name ne 'Moose::Object' } #ignore Moose::Object methods
- $meta->get_all_methods;
-
- # Advanced inheritance support for plugins and the like
- #moose todo: migrate to eliminate CDI compat
- my @action_cache;
- for my $isa ( $meta->superclasses, $class ) {
- if(my $coderef = $isa->can('_action_cache')){
- push(@action_cache, @{ $isa->$coderef });
- }
- }
- 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,
# superior while mantaining really high degree of compat
my $actions;
if( ref($self) ) {
- $actions = $self->actions;
+ $actions = $self->_controller_actions;
} else {
my $cfg = $self->config;
$actions = $self->merge_config_hashes($cfg->{actions}, $cfg->{action});
my $prefix = $self->path_prefix( $c );
$prefix .= '/' if length( $prefix );
-
+
return ( 'Regex', "^${prefix}${value}" );
}
}
sub _parse_PathPrefix_attr {
- my $self = shift;
- return PathPart => $self->path_prefix;
+ my ( $self, $c ) = @_;
+ return PathPart => $self->path_prefix($c);
}
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 );
}
return ( 'ActionClass', $value );
}
-no Moose;
-
__PACKAGE__->meta->make_immutable;
1;
will be bound to 'foo/bar'. The default Root controller is an example
of setting namespace to '' (the null string).
-=head2 path
+=head2 path
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
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
=head1 COPYRIGHT
-This program is free software, you can redistribute it and/or modify
+This library is free software. You can redistribute it and/or modify
it under the same terms as Perl itself.
=cut