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',
# isa => 'ClassName|Catalyst' ?
has _application => (is => 'rw');
-sub _app{ shift->_application(@_) } # eww
+sub _app{ shift->_application(@_) }
sub BUILD {
my ($self, $args) = @_;
return $app->dispatcher->get_action($name, $self->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, $self, $c ) = @_;
+ my $orig = shift;
+ my ( $self, $c ) = @_;
if( ref($self) ){
return $self->$orig if $self->has_action_namespace;
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 sensitivitysettings -- 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
around path_prefix => sub {
my $orig = shift;
my $self = shift;
} 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 });
}
}
return ( 'ActionClass', $value );
}
+no Moose;
+
+__PACKAGE__->meta->make_immutable;
+
1;
__END__