X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=catagits%2FCatalyst-Runtime.git;a=blobdiff_plain;f=lib%2FCatalyst.pm;h=27b421ebf3fb01622e787b5a963717f3a91db90a;hp=92621a10eb151f117ccb27b4d0feb688645a3600;hb=ec4d72594fb7a701c2f36e85ecf9a680ca1abba2;hpb=99e6803ef202f2af101c02f2d7d2abf47d620165 diff --git a/lib/Catalyst.pm b/lib/Catalyst.pm index 92621a1..27b421e 100644 --- a/lib/Catalyst.pm +++ b/lib/Catalyst.pm @@ -63,7 +63,9 @@ has request => ( is => 'rw', default => sub { my $self = shift; - $self->request_class->new($self->_build_request_constructor_args); + my $class = ref $self; + my $composed_request_class = $class->composed_request_class; + return $composed_request_class->new( $self->_build_request_constructor_args); }, lazy => 1, ); @@ -77,11 +79,19 @@ sub _build_request_constructor_args { \%p; } +sub composed_request_class { + my $class = shift; + return $class->_composed_request_class || + $class->_composed_request_class(Moose::Util::with_traits($class->request_class, @{$class->request_class_traits||[]})); +} + has response => ( is => 'rw', default => sub { my $self = shift; - $self->response_class->new($self->_build_response_constructor_args); + my $class = ref $self; + my $composed_response_class = $class->composed_response_class; + return $composed_response_class->new( $self->_build_response_constructor_args); }, lazy => 1, ); @@ -92,6 +102,12 @@ sub _build_response_constructor_args { }; } +sub composed_response_class { + my $class = shift; + return $class->_composed_response_class || + $class->_composed_response_class(Moose::Util::with_traits($class->response_class, @{$class->response_class_traits||[]})); +} + has namespace => (is => 'rw'); sub depth { scalar @{ shift->stack || [] }; } @@ -120,16 +136,25 @@ __PACKAGE__->mk_classdata($_) for qw/components arguments dispatcher engine log dispatcher_class engine_loader context_class request_class response_class stats_class setup_finished _psgi_app loading_psgi_file run_options _psgi_middleware - _data_handlers _encoding _encode_check finalized_default_middleware/; + _data_handlers _encoding _encode_check finalized_default_middleware + request_class_traits response_class_traits stats_class_traits + _composed_request_class _composed_response_class _composed_stats_class/; __PACKAGE__->dispatcher_class('Catalyst::Dispatcher'); __PACKAGE__->request_class('Catalyst::Request'); __PACKAGE__->response_class('Catalyst::Response'); __PACKAGE__->stats_class('Catalyst::Stats'); + +sub composed_stats_class { + my $class = shift; + return $class->_composed_stats_class || + $class->_composed_stats_class(Moose::Util::with_traits($class->stats_class, @{$class->stats_class_traits||[]})); +} + __PACKAGE__->_encode_check(Encode::FB_CROAK | Encode::LEAVE_SRC); # Remember to update this in Catalyst::Runtime as well! -our $VERSION = '5.90084'; +our $VERSION = '5.90089_001'; $VERSION = eval $VERSION if $VERSION =~ /_/; # numify for warning-free dev releases sub import { @@ -1447,6 +1472,10 @@ In general the scheme of the generated URI object will follow the incoming reque however if your targeted action or action chain has the Scheme attribute it will use that instead. +Also, if the targeted Action or Action chain declares Args/CaptureArgs that have +type constraints, we will require that your proposed URL verify on those declared +constraints. + =cut sub uri_for { @@ -1465,60 +1494,59 @@ sub uri_for { carp "uri_for called with undef argument" if grep { ! defined $_ } @args; - my @encoded_args = (); - foreach my $arg (@args) { - if(ref($arg)||'' eq 'ARRAY') { - push @encoded_args, [map { - my $encoded = encode_utf8 $_; - $encoded =~ s/([^$URI::uric])/$URI::Escape::escapes{$1}/go; - $encoded; - } @$arg]; - } else { - push @encoded_args, do { - my $encoded = encode_utf8 $arg; - $encoded =~ s/([^$URI::uric])/$URI::Escape::escapes{$1}/go; - $encoded; - } - } - } - my $target_action = $path->$_isa('Catalyst::Action') ? $path : undef; if ( $path->$_isa('Catalyst::Action') ) { # action object - s|/|%2F|g for @encoded_args; + s|/|%2F|g for @args; my $captures = [ map { s|/|%2F|g; $_; } - ( scalar @encoded_args && ref $encoded_args[0] eq 'ARRAY' - ? @{ shift(@encoded_args) } + ( scalar @args && ref $args[0] eq 'ARRAY' + ? @{ shift(@args) } : ()) ]; my $action = $path; + my $expanded_action = $c->dispatcher->expand_action( $action ); + my $num_captures = $expanded_action->number_of_captures; + # ->uri_for( $action, \@captures_and_args, \%query_values? ) - if( !@encoded_args && $action->number_of_args ) { - my $expanded_action = $c->dispatcher->expand_action( $action ); - my $num_captures = $expanded_action->number_of_captures; - unshift @encoded_args, splice @$captures, $num_captures; + if( !@args && $action->number_of_args ) { + unshift @args, splice @$captures, $num_captures; + } + + if($num_captures) { + unless($expanded_action->match_captures_constraints($c, $captures)) { + carp "captures [@{$captures}] do not match the type constraints in actionchain ending with '$expanded_action'"; + return; + } } - $path = $c->dispatcher->uri_for_action($action, $captures); + $path = $c->dispatcher->uri_for_action($action, $captures); if (not defined $path) { $c->log->debug(qq/Can't find uri_for action '$action' @$captures/) if $c->debug; return undef; } $path = '/' if $path eq ''; + + # At this point @encoded_args is the remaining Args (all captures removed). + if($expanded_action->has_args_constraints) { + unless($expanded_action->match_args($c,\@args)) { + carp "args [@args] do not match the type constraints in action '$expanded_action'"; + return; + } + } } - unshift(@encoded_args, $path); + unshift(@args, $path); unless (defined $path && $path =~ s!^/!!) { # in-place strip my $namespace = $c->namespace; if (defined $path) { # cheesy hack to handle path '../foo' - $namespace =~ s{(?:^|/)[^/]+$}{} while $encoded_args[0] =~ s{^\.\./}{}; + $namespace =~ s{(?:^|/)[^/]+$}{} while $args[0] =~ s{^\.\./}{}; } - unshift(@encoded_args, $namespace || ''); + unshift(@args, $namespace || ''); } # join args with '/', or a blank string - my $args = join('/', grep { defined($_) } @encoded_args); + my $args = join('/', grep { defined($_) } @args); $args =~ s/\?/%3F/g; # STUPID STUPID SPECIAL CASE $args =~ s!^/+!!; @@ -1567,6 +1595,11 @@ sub uri_for { } @keys); } + $base = encode_utf8 $base; + $base =~ s/([^$URI::uric])/$URI::Escape::escapes{$1}/go; + $args = encode_utf8 $args; + $args =~ s/([^$URI::uric])/$URI::Escape::escapes{$1}/go; + my $res = bless(\"${base}${args}${query}", $class); $res; } @@ -2261,8 +2294,10 @@ sub prepare { $c->response->_context($c); - #surely this is not the most efficient way to do things... - $c->stats($class->stats_class->new)->enable($c->use_stats); + if($c->use_stats) { + $c->stats($class->composed_stats_class->new)->enable; + } + if ( $c->debug || $c->config->{enable_catalyst_header} ) { $c->res->headers->header( 'X-Catalyst' => $Catalyst::VERSION ); } @@ -2668,10 +2703,26 @@ sub prepare_write { my $c = shift; $c->engine->prepare_write( $c, @_ ) } Returns or sets the request class. Defaults to L. +=head2 $app->request_class_traits + +An arrayref of Ls which are applied to the request class. + +=head2 $app->composed_request_class + +This is the request class which has been composed with any request_class_traits. + =head2 $c->response_class Returns or sets the response class. Defaults to L. +=head2 $app->response_class_traits + +An arrayref of Ls which are applied to the response class. + +=head2 $app->composed_response_class + +This is the request class which has been composed with any response_class_traits. + =head2 $c->read( [$maxlength] ) Reads a chunk of data from the request body. This method is designed to @@ -2789,6 +2840,15 @@ sub setup_components { $class->components->{ $component } = $class->setup_component($component); } } + + # Inject a component or wrap a stand alone class in an adaptor + #my @configured_comps = grep { not($class->component($_)||'') } + # grep { /^(Model)::|(View)::|(Controller::)/ } + # keys %{$class->config ||+{}}; + + #foreach my $configured_comp(@configured_comps) { + #warn $configured_comp; + #} } =head2 $c->locate_components( $setup_component_config ) @@ -3675,6 +3735,14 @@ by itself. Returns or sets the stats (timing statistics) class. L is used by default. +=head2 $app->stats_class_traits + +A arrayref of Ls that are applied to the stats_class before creating it. + +=head2 $app->composed_stats_class + +this is the stats_class composed with any 'stats_class_traits'. + =head2 $c->use_stats Returns 1 when L<< stats collection|/"-Stats" >> is enabled. @@ -3904,6 +3972,51 @@ parameter to true. =item * +C + +If true, then do not try to character decode any wide characters in your +request URL query or keywords. Most readings of the relevent specifications +suggest these should be UTF-* encoded, which is the default that L +will use, hwoever if you are creating a lot of URLs manually or have external +evil clients, this might cause you trouble. If you find the changes introduced +in Catalyst version 5.90080+ break some of your query code, you may disable +the UTF-8 decoding globally using this configuration. + +This setting takes precedence over C and +C + +=item * + +C + +By default we decode query and keywords in your request URL using UTF-8, which +is our reading of the relevent specifications. This setting allows one to +specify a fixed value for how to decode your query. You might need this if +you are doing a lot of custom encoding of your URLs and not using UTF-8. + +This setting take precedence over C. + +=item * + +C + +Setting this to true will default your query decoding to whatever your +general global encoding is (the default is UTF-8). + +=item * + +C + +In older versions of Catalyst, when more than one action matched the same path +AND all those matching actions declared Args(0), we'd break the tie by choosing +the first action defined. We now normalized how Args(0) works so that it +follows the same rule as Args(N), which is to say when we need to break a tie +we choose the LAST action defined. If this breaks your code and you don't +have time to update to follow the new normalized approach, you may set this +value to true and it will globally revert to the original chaining behavior. + +=item * + C - See L. =item *