X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FController.pm;h=1442649c959c96c54edbda870969677ce1297ec0;hb=ca5d34dfc295012a749a8454d2b213580e03d55c;hp=ee39c7b86b2db48a909dd13007b584ac8f8f8f5a;hpb=c813664857bab8bd99687041937b078b9590bf0c;p=catagits%2FCatalyst-Runtime.git diff --git a/lib/Catalyst/Controller.pm b/lib/Catalyst/Controller.pm index ee39c7b..1442649 100644 --- a/lib/Catalyst/Controller.pm +++ b/lib/Catalyst/Controller.pm @@ -36,15 +36,30 @@ has actions => init_arg => undef, ); +# ->config(actions => { '*' => ... +has _all_actions_attributes => ( + is => 'ro', + isa => 'HashRef', + init_arg => undef, + lazy => 1, + builder => '_build__all_actions_attributes', +); + 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); -} + # trigger lazy builder + $self->_all_actions_attributes; +} +sub _build__all_actions_attributes { + my ($self) = @_; + delete $self->_controller_actions->{'*'} || {}; +} =head1 NAME @@ -182,11 +197,10 @@ around path_prefix => sub { sub get_action_methods { my $self = shift; my $meta = find_meta($self) || confess("No metaclass setup for $self"); - confess("Metaclass " - . ref($meta) . " for " - . $meta->name - . " cannot support register_actions." ) - unless $meta->can('get_nearest_methods_with_attributes'); + confess( + sprintf "Metaclass %s for %s cannot support register_actions.", + ref $meta, $meta->name, + ) unless $meta->can('get_nearest_methods_with_attributes'); my @methods = $meta->get_nearest_methods_with_attributes; # actions specified via config are also action_methods @@ -194,11 +208,9 @@ sub get_action_methods { @methods, map { $meta->find_method_by_name($_) - || confess( 'Action "' - . $_ - . '" is not available from controller ' - . ( ref $self ) ) - } keys %{ $self->_controller_actions } + || confess( sprintf 'Action "%s" is not available from controller %s', + $_, ref $self ) + } keys %{ $self->_controller_actions } ) if ( ref $self ); return uniq @methods; } @@ -225,7 +237,9 @@ sub register_action_methods { foreach my $method (@methods) { my $name = $method->name; - my $attributes = $method->attributes; + # Horrible hack! All method metaclasses should have an attributes + # method, core Moose bug - see r13354. + my $attributes = $method->can('attributes') ? $method->attributes : []; my $attrs = $self->_parse_attrs( $c, $name, @{ $attributes } ); if ( $attrs->{Private} && ( keys %$attrs > 1 ) ) { $c->log->debug( 'Bad action definition "' @@ -248,16 +262,25 @@ sub register_action_methods { } } -sub create_action { +sub action_class { my $self = shift; my %args = @_; my $class = (exists $args{attributes}{ActionClass} - ? $args{attributes}{ActionClass}[0] - : $self->_action_class); + ? $args{attributes}{ActionClass}[0] + : $self->_action_class); + Class::MOP::load_class($class); + return $class; +} + +sub create_action { + my $self = shift; + my %args = @_; + my $class = $self->action_class(%args); my $action_args = $self->config->{action_args}; + my %extra_args = ( %{ $action_args->{'*'} || {} }, %{ $action_args->{ $args{name} } || {} }, @@ -285,23 +308,32 @@ sub _parse_attrs { } } - #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; + my ($actions_config, $all_actions_config); if( ref($self) ) { - $actions = $self->_controller_actions; + $actions_config = $self->_controller_actions; + # No, you're not getting actions => { '*' => ... } with actions in MyApp. + $all_actions_config = $self->_all_actions_attributes; } else { my $cfg = $self->config; - $actions = $self->merge_config_hashes($cfg->{actions}, $cfg->{action}); + $actions_config = $self->merge_config_hashes($cfg->{actions}, $cfg->{action}); + $all_actions_config = {}; } - %raw_attributes = ((exists $actions->{'*'} ? %{$actions->{'*'}} : ()), - %raw_attributes, - (exists $actions->{$name} ? %{$actions->{$name}} : ())); + %raw_attributes = ( + %raw_attributes, + # Note we deep copy array refs here to stop crapping on config + # when attributes are parsed. RT#65463 + exists $actions_config->{$name} ? map { ref($_) eq 'ARRAY' ? [ @$_ ] : $_ } %{ $actions_config->{$name } } : (), + ); + # Private actions with additional attributes will raise a warning and then + # be ignored. Adding '*' arguments to the default _DISPATCH / etc. methods, + # which are Private, will prevent those from being registered. They should + # probably be turned into :Actions instead, or we might want to otherwise + # disambiguate between those built-in internal actions and user-level + # Private ones. + %raw_attributes = (%{ $all_actions_config }, %raw_attributes) + unless $raw_attributes{Private}; my %final_attributes; @@ -446,34 +478,45 @@ of setting namespace to '' (the null string). Sets 'path_prefix', as described below. -=head2 action_args +=head2 action -Allows you to set instantiation arguments on your custom Actions or ActionRoles. -You can set args globally (shared across all actions) and specifically (for a -single action). +Allows you to set the attributes that the dispatcher creates actions out of. +This allows you to do 'rails style routes', or override some of the +attribute definitions of actions composed from Roles. +You can set arguments globally (for all actions of the controller) and +specifically (for a single action). - package MyApp::Web::Controller::MyController; - use parent 'Catalyst::Controller'; + __PACKAGE__->config( + action => { + '*' => { Chained => 'base', Args => 0 }, + base => { Chained => '/', PathPart => '', CaptureArgs => 0 }, + }, + ); + +In the case above every sub in the package would be made into a Chain +endpoint with a URI the same as the sub name for each sub, chained +to the sub named C. Ergo dispatch to C would call the +C method, then the C method. + +=head2 action_args - __PACKAGE__->config({ +Allows you to set constructor arguments on your actions. You can set arguments +globally and specifically (as above). +This is particularly useful when using Cs +(L) and custom Ces. + + __PACKAGE__->config( action_args => { - '*' => {globalarg1=>'hello', globalarg2=>'goodbye'}, - 'specific_action' => {customarg=>'arg1'}, - }, - }); - - sub specific_action :Path('') ActionClass('CustomActionClass') {} - - 1; - -In the case above, your 'CustomActionClass' would get passed the following -arguments when it is instantiated: (globalarg1=>'hello', globalarg2=>'goodbye', -'customarg=>'arg1'). Please note that the order the arguments are passed are not -certain to be in the order declared. - -As with all other configuration hashes, you can set values inline with your -controller (as above) or centrally via a configuration file (such as you might -use with the ConfigLoader plugin). + '*' => { globalarg1 => 'hello', globalarg2 => 'goodbye' }, + 'specific_action' => { customarg => 'arg1' }, + }, + ); + +In the case above the action class associated with C would get +passed the following arguments, in addition to the normal action constructor +arguments, when it is instantiated: + + (globalarg1 => 'hello', globalarg2 => 'goodbye', customarg => 'arg1') =head1 METHODS @@ -518,6 +561,11 @@ action methods for this package. Creates action objects for a set of action methods using C< create_action >, and registers them with the dispatcher. +=head2 $self->action_class(%args) + +Used when a controller is creating an action to determine the correct base +action class to use. + =head2 $self->create_action(%args) Called with a hash of data to be use for construction of a new