package Catalyst::Controller;
#switch to BEGIN { extends qw/ ... /; } ?
+use MRO::Compat;
+use mro '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',
# isa => 'ClassName|Catalyst' ?
has _application => (is => 'rw');
-sub _app{ shift->_application(@_) } # eww
+sub _app{ shift->_application(@_) }
sub BUILD {
my ($self, $args) = @_;
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;
+sub new {
my $self = shift;
my $app = $_[0];
- my $new = $self->$orig(@_);
+ my $new = $self->next::method(@_);
$new->_application( $app );
return $new;
-};
+}
sub action_for {
my ( $self, $name ) = @_;
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
+
+#we are wrapping the accessor, so just uyse a modifier since a normal sub would
+#just be overridden by the generated moose method
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;
- } else {
+ } else {
+ warn "action_namespace called as class method";
+ # if the following won't change at runtime it should be lazy_building thing
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
+ #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
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;
+
1;
__END__
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.