use MooseX::Declare;
+use MooseX::Role::Parameterized ();
-class CatalystX::Declare::Keyword::Action
- with MooseX::Declare::Syntax::KeywordHandling {
+class CatalystX::Declare::Keyword::Action {
use Carp qw( croak );
use Perl6::Junction qw( any );
use Data::Dump qw( pp );
use MooseX::Types::Util qw( has_available_type_export );
- use Moose::Util qw( add_method_modifier );
+ use Moose::Util qw( add_method_modifier ensure_all_roles );
use Class::Inspector;
use Class::MOP;
use constant STOP_PARSING => '__MXDECLARE_STOP_PARSING__';
use constant UNDER_VAR => '$CatalystX::Declare::SCOPE::UNDER';
+ use constant UNDER_STACK => '@CatalystX::Declare::SCOPE::UNDER_STACK';
use aliased 'CatalystX::Declare::Action::CatchValidationError';
+ use aliased 'CatalystX::Declare::Context::StringParsing';
use aliased 'MooseX::Method::Signatures::Meta::Method';
use aliased 'MooseX::MethodAttributes::Role::Meta::Method', 'AttributeRole';
+ use aliased 'MooseX::MethodAttributes::Role::Meta::Role', 'AttributeMetaRole';
method parse (Object $ctx, Str :$modifier?, Int :$skipped_declarator = 0) {
for @populators;
unless ($attributes{Private}) {
- $attributes{PathPart} ||= "'$name'";
+ $attributes{PathPart} ||= $name;
delete $attributes{CaptureArgs}
if exists $attributes{Args};
if ($attributes{Private}) {
delete $attributes{ $_ }
- for qw( Args CaptureArgs Chained Signature Subname Action );
+ for qw( Args CaptureArgs Chained Signature Private );
}
+ # inject a hashref for resolving runtime attribute values
+ $self->_inject_attributes($ctx, \%attributes);
+
+ # our declaration is followed by a block
if ($ctx->peek_next_char eq '{') {
$ctx->inject_if_block($ctx->scope_injector_call . $method->injectable_code);
}
+
+ # there is no block, so we insert one.
else {
$ctx->inject_code_parts_here(
sprintf '{ %s%s }',
);
}
- my @attributes;
- for my $attr (keys %attributes) {
- push @attributes,
- map { sprintf '%s%s', $attr, defined($_) ? sprintf('(%s)', $_) : '' }
- (ref($attributes{ $attr }) eq 'ARRAY')
- ? @{ $attributes{ $attr } }
- : $attributes{ $attr };
- }
+ my $compile_attrs = sub {
+ my $attributes = shift;;
+ my @attributes;
+
+ for my $attr (keys %$attributes) {
+ my $value = $attributes->{ $attr };
- return $ctx->shadow(sub (&) {
+ # the compiletime chained attr might contain the under global var name
+ next if $attr eq 'Chained' and $value eq UNDER_VAR;
+
+ push @attributes,
+ map { sprintf '%s%s', $attr, defined($_) ? sprintf('(%s)', $_) : '' }
+ (ref($value) eq 'ARRAY')
+ ? @$value
+ : $value;
+ }
+
+ return \@attributes;
+ };
+
+ return $ctx->shadow(sub {
my $class = caller;
+ my $attrs = shift;
my $body = shift;
- $method->_set_actual_body($body);
- $method->{attributes} = \@attributes;
+ # the runtime-resolved name
+ my $name = $attrs->{Subname};
+
+ # in case no hashref was specified
+ $body = $attrs and $attrs = {}
+ if ref $attrs eq 'CODE';
+
+ # default path part to runtime-resolved name
+ unless ($attrs->{Private}) {
+
+ $attrs->{PathPart} = $attrs->{Subname}
+ unless defined $attrs->{PathPart};
+ }
+
+ # in CXD we are explicit about chained values, an undefined
+ # value means we defaulted to the outer-scope under and there
+ # was none.
+ delete $attrs->{Chained}
+ unless defined $attrs->{Chained};
+
+ # some attrs need to be single quoted in their stringified forms
+ defined($attrs->{ $_ }) and $attrs->{ $_ } = sprintf "'%s'", $attrs->{ $_ }
+ for qw( Chained PathPart );
+ # merge runtime and compiletime attrs
+ my %full_attrs = (%attributes, %$attrs);
+ my $compiled_attrs = $compile_attrs->(\%full_attrs);
+
+ my $real_method = $method->reify(
+ actual_body => $body,
+ attributes => $compiled_attrs,
+ name => $name,
+ );
+
+ # NYI
if ($modifier) {
- add_method_modifier $class, $modifier, [$name, $method];
+ add_method_modifier $class, $modifier, [$name, $real_method];
}
else {
- $class->meta->add_method($name, $method);
- $class->meta->register_method_attributes($class->can($method->name), \@attributes);
+ my $prepare_meta = sub {
+ my ($meta) = @_;
+
+ $meta->add_method($name, $real_method);
+ $meta->register_method_attributes($meta->name->can($real_method->name), $compiled_attrs);
+ };
+
+ if ($ctx->stack->[-1] and $ctx->stack->[-1]->is_parameterized) {
+ my $real_meta = MooseX::Role::Parameterized->current_metaclass;
+
+ $real_meta->meta->make_mutable
+ if $real_meta->meta->is_immutable;
+ ensure_all_roles $real_meta->meta, AttributeMetaRole
+ if $real_meta->isa('Moose::Meta::Role');
+
+ $real_meta->$prepare_meta;
+ }
+ else {
+
+ $class->meta->$prepare_meta;
+ }
}
});
}
method _handle_action_option (Object $ctx, HashRef $attrs) {
# action name
- my $name = $ctx->strip_name
+ my $name = $self->_strip_actionpath($ctx, interpolate => 1)
or croak "Anonymous actions not yet supported";
$ctx->skipspace;
my $populator;
+ # shortcut under base option is basically handled by the under handler
if (substr($ctx->get_linestr, $ctx->offset, 2) eq '<-') {
my $linestr = $ctx->get_linestr;
substr($linestr, $ctx->offset, 2) = '';
push @{ $attrs->{CatalystX_Declarative_ActionRoles} ||= [] }, CatchValidationError;
- if (defined $CatalystX::Declare::SCOPE::UNDER) {
- $attrs->{Chained} ||= $CatalystX::Declare::SCOPE::UNDER;
- }
+ # default chained base to the global under var, to be resolved at runtime
+ $attrs->{Chained} ||= UNDER_VAR;
return unless $populator;
return $populator;
method _handle_under_option (Object $ctx, HashRef $attrs) {
- my $target = $self->_strip_actionpath($ctx);
+ my $target = $self->_strip_actionpath($ctx, interpolate => 1);
$ctx->skipspace;
if ($ctx->peek_next_char eq '{' and $self->identifier eq 'under') {
$ctx->inject_if_block(
- sprintf '%s; local %s; BEGIN { %s = qq(%s) };',
- $ctx->scope_injector_call,
- UNDER_VAR,
+ $ctx->scope_injector_call .
+ sprintf ';local %s = %s;',
UNDER_VAR,
$target,
);
return STOP_PARSING;
}
- $attrs->{Chained} = "'$target'";
+ $attrs->{Chained} = $target;
return sub {
my $method = shift;
$ctx->skipspace;
- my $path = $self->_strip_actionpath($ctx);
- $attrs->{PathPart} = "'$path'";
+ my $path = $self->_strip_actionpath($ctx, interpolate => 1);
+ $attrs->{PathPart} = $path;
return;
}
method _count_positional_arguments (Object $method) {
- my $signature = $method->_parsed_signature;
+ my $signature = $method->parsed_signature;
if ($signature->has_positional_params) {
my $count = @{ scalar($signature->positional_params) };
return 0;
}
- method _strip_actionpath (Object $ctx) {
+ method _inject_attributes (Object $ctx, HashRef $attrs) {
+
+ # attrs that need to be runtime-resolved
+ my @inject = qw( Chained PathPart Subname );
+
+ # turn specific attributes into a hashref
+ my $code = sprintf ' +{ %s }, sub ', # the ', sub ' turns method +{ ... } { ... } into
+ join ', ', # method +{ ... }, sub { ... }
+ map { (@$_) }
+ map { defined( $_->[1] ) ? $_ : [$_->[0], 'undef'] }
+ map { [pp($_), $attrs->{ $_ }] }
+ grep { defined $attrs->{ $_ } }
+ @inject;
+
+ # inject the hashref code before the action body
+ $ctx->inject_code_parts_here($code);
+ $ctx->inc_offset(length $code);
+ }
+
+ method _strip_actionpath (Object $ctx, :$interpolate?) {
$ctx->skipspace;
my $linestr = $ctx->get_linestr;
my $rest = substr($linestr, $ctx->offset);
+ my $interp = sub { $interpolate ? "'$_[0]'" : $_[0] };
+ # find simple barewords
if ($rest =~ /^ ( [_a-z] [_a-z0-9]* ) \b/ix) {
substr($linestr, $ctx->offset, length($1)) = '';
$ctx->set_linestr($linestr);
- return $1;
+ return $interp->($1);
}
+
+ # allow single quoted more complex barewords
elsif ($rest =~ /^ ' ( (?:[.:;,_a-z0-9]|\/)* ) ' /ix) {
substr($linestr, $ctx->offset, length($1) + 2) = '';
$ctx->set_linestr($linestr);
- return $1;
+ return $interp->($1);
}
+
+ # double quoted strings and variables
+ elsif ($interpolate and my $str = $ctx->get_string) {
+ return $str;
+ }
+
+ # not suitable as action path
else {
croak "Invalid syntax for action path: $rest";
}
}
+
+ # down here because it requires the parse method
+ with 'MooseX::Declare::Syntax::KeywordHandling';
+
+ around context_traits { $self->$orig, StringParsing }
}
__END__
# the final keyword can be used to be more
# visually explicit about end-points
final action some_action { ... }
+
+ # type dispatching works
+ final action with_str (Str $x) as via_type;
+ final action with_int (Int $x) as via_type;
}
# of course you can also chain to external actions
$ctx->stash(item => $self->get_item);
}
+=head2 Why $ctx instead of $c
+
+Some might ask why the context object is called C<$ctx> instead of the usual
+C<$c>. The reason is simple: It's an opinionated best practice, since C<$ctx>
+stands out more.
+
=head2 Setting a Path Part
As usual with Catalyst actions, the path part (the public name of this part of
=head2 Arguments
You can use signatures like you are use to from L<MooseX::Method::Signatures>
-to declare action parameters. The number of arguments will be used during
-dispatching. Dispatching by type constraint is planned but not yet implemented.
+to declare action parameters. The number of positinoal arguments will be used
+during dispatching as well as their types.
The signature follows the action name:
=head2 Validation
-Currently, when the arguments do not fit the signature because of a L<Moose>
-validation error, the response body will be set to C<Bad Request> and the
-status to C<400>. This only applies when debug mode is off. If it is turned on,
-the error message will be prefixed with C<BAD REQUEST: >.
+The signatures are now validated during dispatching-time, and an action with
+a non-matching signature (number of positional arguments and their types) will
+not be dispatched to. This means that
+
+ action base under '/' as '';
+
+ under base {
+
+ final as double, action double_integer (Int $x) {
+ $ctx->response->body( $x * 2 );
+ }
+
+ final as double, action double_string (Str $x) {
+ $ctx->response->body( $x x 2 );
+ }
+ }
+
+will return C<foofoo> when called as C</double/foo> and C<46> when called as
+C</double/23>.
=head2 Actions and Method Modifiers
}
}
+=head2 Action Classes
+
+B<This option is even more experimental>
+
+You might want to create an action with a different class than the usual
+L<Catalyst::Action>. A usual suspect here is L<Catalyst::Action::RenderView>.
+You can use the C<isa> option (did I mention it's experimental?) to specify
+what class to use:
+
+ controller MyApp::Web::Controller::Root {
+
+ $CLASS->config(namespace => '');
+
+ action end isa RenderView;
+ }
+
+The loaded class will be L<Moose>ified, so we are able to apply essential
+roles.
+
=head1 ROLES
=over
projects / catagits/CatalystX-Declare.git / blobdiff