use base qw/Catalyst::Component Catalyst::AttrContainer/;
use Moose;
+use Class::MOP::Object ();
use Scalar::Util qw/blessed/;
use Catalyst::Exception;
use Catalyst::Utils;
-use Class::Inspector;
+
+with 'Catalyst::Component::Role::CaptureApp';
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',
init_arg => undef,
);
-# isa => 'ClassName|Catalyst' ?
-has _application => (is => 'rw');
-sub _app{ shift->_application(@_) } # eww
-
sub BUILD {
my ($self, $args) = @_;
my $action = delete $args->{action} || {};
my ( $self, $c ) = @_;
if ( ref $c->action
&& $c->action->can('execute')
- && $c->req->action )
+ && defined $c->req->action )
{
$c->action->dispatch( $c );
}
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
+#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} }
- 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) || [] };
- }
+ my $meta = $self->Class::MOP::Object::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
- #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 });
}
}
sub _parse_Path_attr {
my ( $self, $c, $name, $value ) = @_;
- $value ||= '';
+ $value = '' if !defined $value;
if ( $value =~ m!^/! ) {
return ( 'Path', $value );
}
sub _parse_LocalRegex_attr {
my ( $self, $c, $name, $value ) = @_;
unless ( $value =~ s/^\^// ) { $value = "(?:.*?)$value"; }
- return ( 'Regex', '^' . $self->path_prefix($c) . "/${value}" );
+
+ my $prefix = $self->path_prefix( $c );
+ $prefix .= '/' if length( $prefix );
+
+ return ( 'Regex', "^${prefix}${value}" );
}
sub _parse_LocalRegexp_attr { shift->_parse_LocalRegex_attr(@_); }
+sub _parse_Chained_attr {
+ my ($self, $c, $name, $value) = @_;
+
+ if (defined($value) && length($value)) {
+ if ($value eq '.') {
+ $value = '/'.$self->action_namespace($c);
+ } elsif (my ($rel, $rest) = $value =~ /^((?:\.{2}\/)+)(.*)$/) {
+ my @parts = split '/', $self->action_namespace($c);
+ my @levels = split '/', $rel;
+
+ $value = '/'.join('/', @parts[0 .. $#parts - @levels], $rest);
+ } elsif ($value !~ m/^\//) {
+ my $action_ns = $self->action_namespace($c);
+
+ if ($action_ns) {
+ $value = '/'.join('/', $action_ns, $value);
+ } else {
+ $value = '/'.$value; # special case namespace '' (root)
+ }
+ }
+ } else {
+ $value = '/'
+ }
+
+ return Chained => $value;
+}
+
+sub _parse_ChainedParent_attr {
+ my ($self, $c, $name, $value) = @_;
+ return $self->_parse_Chained_attr($c, $name, '../'.$name);
+}
+
+sub _parse_PathPrefix_attr {
+ my $self = shift;
+ return PathPart => $self->path_prefix;
+}
+
sub _parse_ActionClass_attr {
my ( $self, $c, $name, $value ) = @_;
unless ( $value =~ s/^\+// ) {
return ( 'ActionClass', $value );
}
+no Moose;
+
+__PACKAGE__->meta->make_immutable;
+
1;
__END__
=head2 $self->path_prefix($c)
-Returns the default path prefix for :Local, :LocalRegex and relative
-:Path actions in this component. Defaults to the action_namespace or
+Returns the default path prefix for :PathPrefix, :Local, :LocalRegex and
+relative :Path actions in this component. Defaults to the action_namespace or
can be overridden from the "path" config key.
=head2 $self->create_action(%args)
Returns the application instance stored by C<new()>
-=head1 AUTHOR
+=head1 AUTHORS
-Sebastian Riedel, C<sri@oook.de>
-Marcus Ramberg C<mramberg@cpan.org>
+Catalyst Contributors, see Catalyst.pm
=head1 COPYRIGHT