package Catalyst::Controller;
#switch to BEGIN { extends qw/ ... /; } ?
-use Class::C3;
use base qw/Catalyst::Component Catalyst::AttrContainer/;
use Moose;
has path_prefix =>
(
- is => 'ro',
+ is => 'rw',
isa => 'Str',
init_arg => 'path',
predicate => 'has_path_prefix',
has action_namespace =>
(
- is => 'ro',
+ is => 'rw',
isa => 'Str',
init_arg => 'namespace',
predicate => 'has_action_namespace',
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 ) = @_;
#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};
}
}
- 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
} 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;
};
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 });
}
}