X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst.pm;h=7112a597f1064f6c511237ca99644b4457c3fa0a;hb=dd4530ecdc4684838d9c0e9dc00adebb6100b022;hp=6523d21917f3a786eafc7c3df0957cb07baf166b;hpb=02336198551ec2d7edfa74911919b8804bfc69c8;p=catagits%2FCatalyst-Runtime.git diff --git a/lib/Catalyst.pm b/lib/Catalyst.pm index 6523d21..7112a59 100644 --- a/lib/Catalyst.pm +++ b/lib/Catalyst.pm @@ -51,6 +51,8 @@ use Catalyst::Middleware::Stash; use Plack::Util; use Class::Load 'load_class'; use Encode 2.21 'decode_utf8', 'encode_utf8'; +use Scalar::Util; +use Ref::Util qw(is_plain_arrayref is_plain_coderef is_plain_hashref is_plain_scalarref is_regexpref); BEGIN { require 5.008003; } @@ -81,6 +83,8 @@ sub _build_request_constructor_args { sub composed_request_class { my $class = shift; + return $class->_composed_request_class if $class->_composed_request_class; + my @traits = (@{$class->request_class_traits||[]}, @{$class->config->{request_class_traits}||[]}); # For each trait listed, figure out what the namespace is. First we try the $trait @@ -92,8 +96,14 @@ sub composed_request_class { Class::Load::load_first_existing_class($_, $class.'::'.$trait_ns.'::'. $_, 'Catalyst::'.$trait_ns.'::'.$_) } @traits; - return $class->_composed_request_class || - $class->_composed_request_class(Moose::Util::with_traits($class->request_class, @normalized_traits)); + if ($class->debug && scalar(@normalized_traits)) { + my $column_width = Catalyst::Utils::term_width() - 6; + my $t = Text::SimpleTable->new($column_width); + $t->row($_) for @normalized_traits; + $class->log->debug( "Composed Request Class Traits:\n" . $t->draw . "\n" ); + } + + return $class->_composed_request_class(Moose::Util::with_traits($class->request_class, @normalized_traits)); } has response => ( @@ -115,6 +125,8 @@ sub _build_response_constructor_args { sub composed_response_class { my $class = shift; + return $class->_composed_response_class if $class->_composed_response_class; + my @traits = (@{$class->response_class_traits||[]}, @{$class->config->{response_class_traits}||[]}); my $trait_ns = 'TraitFor::Response'; @@ -122,8 +134,14 @@ sub composed_response_class { Class::Load::load_first_existing_class($_, $class.'::'.$trait_ns.'::'. $_, 'Catalyst::'.$trait_ns.'::'.$_) } @traits; - return $class->_composed_response_class || - $class->_composed_response_class(Moose::Util::with_traits($class->response_class, @normalized_traits)); + if ($class->debug && scalar(@normalized_traits)) { + my $column_width = Catalyst::Utils::term_width() - 6; + my $t = Text::SimpleTable->new($column_width); + $t->row($_) for @normalized_traits; + $class->log->debug( "Composed Response Class Traits:\n" . $t->draw . "\n" ); + } + + return $class->_composed_response_class(Moose::Util::with_traits($class->response_class, @normalized_traits)); } has namespace => (is => 'rw'); @@ -166,6 +184,8 @@ __PACKAGE__->stats_class('Catalyst::Stats'); sub composed_stats_class { my $class = shift; + return $class->_composed_stats_class if $class->_composed_stats_class; + my @traits = (@{$class->stats_class_traits||[]}, @{$class->config->{stats_class_traits}||[]}); my $trait_ns = 'TraitFor::Stats'; @@ -173,14 +193,20 @@ sub composed_stats_class { Class::Load::load_first_existing_class($_, $class.'::'.$trait_ns.'::'. $_, 'Catalyst::'.$trait_ns.'::'.$_) } @traits; - return $class->_composed_stats_class || - $class->_composed_stats_class(Moose::Util::with_traits($class->stats_class, @normalized_traits)); + if ($class->debug && scalar(@normalized_traits)) { + my $column_width = Catalyst::Utils::term_width() - 6; + my $t = Text::SimpleTable->new($column_width); + $t->row($_) for @normalized_traits; + $class->log->debug( "Composed Stats Class Traits:\n" . $t->draw . "\n" ); + } + + return $class->_composed_stats_class(Moose::Util::with_traits($class->stats_class, @normalized_traits)); } __PACKAGE__->_encode_check(Encode::FB_CROAK | Encode::LEAVE_SRC); # Remember to update this in Catalyst::Runtime as well! -our $VERSION = '5.90096'; +our $VERSION = '5.90114'; $VERSION = eval $VERSION if $VERSION =~ /_/; # numify for warning-free dev releases sub import { @@ -598,7 +624,7 @@ will be an empty arrayref. sub error { my $c = shift; if ( $_[0] ) { - my $error = ref $_[0] eq 'ARRAY' ? $_[0] : [@_]; + my $error = is_plain_arrayref($_[0]) ? $_[0] : [@_]; croak @$error unless ref $c; push @{ $c->{error} }, @$error; } @@ -606,13 +632,17 @@ sub error { return $c->{error} || []; } - =head2 $c->state Contains the return value of the last executed action. Note that << $c->state >> operates in a scalar context which means that all values it returns are scalar. +Please note that if an action throws an exception, the value of state +should no longer be considered the return if the last action. It is generally +going to be 0, which indicates an error state. Examine $c->error for error +details. + =head2 $c->clear_errors Clear errors. You probably don't want to clear the errors unless you are @@ -699,13 +729,13 @@ sub _comp_names_search_prefixes { # undef for a name will return all return keys %eligible if !defined $name; - my $query = $name->$_isa('Regexp') ? $name : qr/^$name$/i; + my $query = is_regexpref($name) ? $name : qr/^$name$/i; my @result = grep { $eligible{$_} =~ m{$query} } keys %eligible; return @result if @result; # if we were given a regexp to search against, we're done. - return if $name->$_isa('Regexp'); + return if is_regexpref($name); # skip regexp fallback if configured return @@ -766,7 +796,7 @@ sub _comp_names { sub _filter_component { my ( $c, $comp, @args ) = @_; - if(ref $comp eq 'CODE') { + if(is_plain_coderef($comp)) { $comp = $comp->(); } @@ -803,10 +833,15 @@ sub controller { my $appclass = ref($c) || $c; if( $name ) { - unless ( $name->$_isa('Regexp') ) { # Direct component hash lookup to avoid costly regexps + unless ( is_regexpref($name) ) { # Direct component hash lookup to avoid costly regexps my $comps = $c->components; my $check = $appclass."::Controller::".$name; return $c->_filter_component( $comps->{$check}, @args ) if exists $comps->{$check}; + foreach my $path (@{$appclass->config->{ setup_components }->{ search_extra }}) { + next unless $path =~ /.*::Controller/; + $check = $path."::".$name; + return $c->_filter_component( $comps->{$check}, @args ) if exists $comps->{$check}; + } } my @result = $c->_comp_search_prefixes( $name, qw/Controller C/ ); return map { $c->_filter_component( $_, @args ) } @result if ref $name; @@ -842,10 +877,15 @@ sub model { my ( $c, $name, @args ) = @_; my $appclass = ref($c) || $c; if( $name ) { - unless ( $name->$_isa('Regexp') ) { # Direct component hash lookup to avoid costly regexps + unless ( is_regexpref($name) ) { # Direct component hash lookup to avoid costly regexps my $comps = $c->components; my $check = $appclass."::Model::".$name; return $c->_filter_component( $comps->{$check}, @args ) if exists $comps->{$check}; + foreach my $path (@{$appclass->config->{ setup_components }->{ search_extra }}) { + next unless $path =~ /.*::Model/; + $check = $path."::".$name; + return $c->_filter_component( $comps->{$check}, @args ) if exists $comps->{$check}; + } } my @result = $c->_comp_search_prefixes( $name, qw/Model M/ ); return map { $c->_filter_component( $_, @args ) } @result if ref $name; @@ -901,7 +941,7 @@ sub view { my $appclass = ref($c) || $c; if( $name ) { - unless ( $name->$_isa('Regexp') ) { # Direct component hash lookup to avoid costly regexps + unless ( is_regexpref($name) ) { # Direct component hash lookup to avoid costly regexps my $comps = $c->components; my $check = $appclass."::View::".$name; if( exists $comps->{$check} ) { @@ -910,6 +950,11 @@ sub view { else { $c->log->warn( "Attempted to use view '$check', but does not exist" ); } + foreach my $path (@{$appclass->config->{ setup_components }->{ search_extra }}) { + next unless $path =~ /.*::View/; + $check = $path."::".$name; + return $c->_filter_component( $comps->{$check}, @args ) if exists $comps->{$check}; + } } my @result = $c->_comp_search_prefixes( $name, qw/View V/ ); return map { $c->_filter_component( $_, @args ) } @result if ref $name; @@ -1393,7 +1438,7 @@ EOF } my @middleware = map { - ref $_ eq 'CODE' ? + is_plain_coderef($_) ? "Inline Coderef" : (ref($_) .' '. ($_->can('VERSION') ? $_->VERSION || '' : '') || '') } $class->registered_middlewares; @@ -1454,6 +1499,11 @@ EOF $class->log->warn("This setting is deprecated and planned to be removed in Catalyst 5.81."); } + # call these so we pre setup the composed classes + $class->composed_request_class; + $class->composed_response_class; + $class->composed_stats_class; + $class->setup_finalize; # Flush the log for good measure (in case something turned off 'autoflush' early) @@ -1557,10 +1607,10 @@ sub uri_for { $path .= '/'; } - my $fragment = ((scalar(@args) && ref($args[-1]) eq 'SCALAR') ? pop @args : undef ); + my $fragment = ((scalar(@args) && is_plain_scalarref($args[-1])) ? pop @args : undef ); unless(blessed $path) { - if ($path =~ s/#(.+)$//) { + if (defined($path) and $path =~ s/#(.+)$//) { if(defined($1) and $fragment) { carp "Abiguious fragment declaration: You cannot define a fragment in '$path' and as an argument '$fragment'"; } @@ -1571,7 +1621,7 @@ sub uri_for { } my $params = - ( scalar @args && ref $args[$#args] eq 'HASH' ? pop @args : {} ); + ( scalar @args && is_plain_hashref($args[$#args]) ? pop @args : {} ); undef($path) if (defined $path && $path eq ''); @@ -1581,7 +1631,7 @@ sub uri_for { if ( $path->$_isa('Catalyst::Action') ) { # action object s|/|%2F|g for @args; my $captures = [ map { s|/|%2F|g; $_; } - ( scalar @args && ref $args[0] eq 'ARRAY' + ( scalar @args && is_plain_arrayref($args[0]) ? @{ shift(@args) } : ()) ]; @@ -1673,7 +1723,7 @@ sub uri_for { $key =~ s/([^A-Za-z0-9\-_.!~*'() ])/$URI::Escape::escapes{$1}/go; $key =~ s/ /+/g; - "${key}=$param"; } ( ref $val eq 'ARRAY' ? @$val : $val )); + "${key}=$param"; } ( is_plain_arrayref($val) ? @$val : $val )); } @keys); } @@ -1986,7 +2036,7 @@ via $c->error. sub execute { my ( $c, $class, $code ) = @_; $class = $c->component($class) || $class; - $c->state(0); + #$c->state(0); if ( $c->depth >= $RECURSION ) { my $action = $code->reverse(); @@ -2038,7 +2088,7 @@ sub execute { } $c->error($error); } - $c->state(0); + #$c->state(0); } return $c->state; } @@ -2271,7 +2321,7 @@ sub finalize_encoding { if( ($res->encodable_response) and (defined($res->body)) and - (ref(\$res->body) eq 'SCALAR') + (is_plain_scalarref(\$res->body)) ) { $c->res->body( $c->encoding->encode( $c->res->body, $c->_encode_check ) ); @@ -2385,7 +2435,6 @@ sub prepare { my $c = $class->context_class->new({ $uploadtmp ? (_uploadtmp => $uploadtmp) : ()}); $c->response->_context($c); - $c->stats($class->stats_class->new)->enable($c->use_stats); if ( $c->debug || $c->config->{enable_catalyst_header} ) { @@ -2419,9 +2468,6 @@ sub prepare { # VERY ugly and probably shouldn't rely on ->finalize actually working catch { # failed prepare is always due to an invalid request, right? - $c->response->status(400); - $c->response->content_type('text/plain'); - $c->response->body('Bad Request'); # Note we call finalize and then die here, which escapes # finalize being called in the enclosing block.. # It in fact couldn't be called, as we don't return $c.. @@ -2429,11 +2475,25 @@ sub prepare { # breaking compat for people doing crazy things (we should set # the 400 and just return the ctx here IMO, letting finalize get called # above... - $c->finalize; - die $_; + if ( $c->_handle_http_exception($_) ) { + foreach my $err (@{$c->error}) { + $c->log->error($err); + } + $c->clear_errors; + $c->log->_flush if $c->log->can('_flush'); + $_->can('rethrow') ? $_->rethrow : croak $_; + } else { + $c->response->status(400); + $c->response->content_type('text/plain'); + $c->response->body('Bad Request'); + $c->finalize; + die $_; + } }; $c->log_request; + $c->{stash} = $c->stash; + Scalar::Util::weaken($c->{stash}); return $c; } @@ -2684,7 +2744,7 @@ sub log_request_parameters { for my $key ( sort keys %$params ) { my $param = $params->{$key}; my $value = defined($param) ? $param : ''; - $t->row( $key, ref $value eq 'ARRAY' ? ( join ', ', @$value ) : $value ); + $t->row( $key, is_plain_arrayref($value) ? ( join ', ', @$value ) : $value ); } $c->log->debug( ucfirst($type) . " Parameters are:\n" . $t->draw ); } @@ -2712,7 +2772,7 @@ sub log_request_uploads { ); for my $key ( sort keys %$uploads ) { my $upload = $uploads->{$key}; - for my $u ( ref $upload eq 'ARRAY' ? @{$upload} : ($upload) ) { + for my $u ( is_plain_arrayref($upload) ? @{$upload} : ($upload) ) { $t->row( $key, $u->filename, $u->type, $u->size ); } } @@ -2812,7 +2872,7 @@ We try each possible role in turn (and throw an error if none load) MyApp::TraitFor::Request::Foo Catalyst::TraitFor::Request::Foo -The namespace part 'TraitFor::Request' was choosen to assist in backwards +The namespace part 'TraitFor::Request' was chosen to assist in backwards compatibility with L which previously provided these features in a stand alone package. @@ -2843,7 +2903,7 @@ We try each possible role in turn (and throw an error if none load) MyApp::TraitFor::Response::Foo Catalyst::TraitFor::Responset::Foo -The namespace part 'TraitFor::Response' was choosen to assist in backwards +The namespace part 'TraitFor::Response' was chosen to assist in backwards compatibility with L which previously provided these features in a stand alone package. @@ -2972,7 +3032,7 @@ sub setup_components { # All components are registered, now we need to 'init' them. foreach my $component_name (@comps, @injected) { $class->components->{$component_name} = $class->components->{$component_name}->() if - (ref($class->components->{$component_name}) || '') eq 'CODE'; + is_plain_coderef($class->components->{$component_name}); } } @@ -3090,7 +3150,7 @@ sub locate_components { my $config = shift; my @paths = qw( ::M ::Model ::V ::View ::C ::Controller ); - my $extra = delete $config->{ search_extra } || []; + my $extra = $config->{ search_extra } || []; unshift @paths, @$extra; @@ -3515,15 +3575,44 @@ sub setup_encoding { =head2 handle_unicode_encoding_exception -Hook to let you customize how encoding errors are handled. By default -we just throw an exception. Receives a hashref of debug information. -Example: +Hook to let you customize how encoding errors are handled. By default +we just throw an exception and the default error page will pick it up. +Receives a hashref of debug information. Example of call (from the +Catalyst internals): - $c->handle_unicode_encoding_exception({ + my $decoded_after_fail = $c->handle_unicode_encoding_exception({ param_value => $value, error_msg => $_, - encoding_step => 'params', - }); + encoding_step => 'params', + }); + +The calling code expects to receive a decoded string or an exception. + +You can override this for custom handling of unicode errors. By +default we just die. If you want a custom response here, one approach +is to throw an HTTP style exception, instead of returning a decoded +string or throwing a generic exception. + + sub handle_unicode_encoding_exception { + my ($c, $params) = @_; + HTTP::Exception::BAD_REQUEST->throw(status_message=>$params->{error_msg}); + } + +Alternatively you can 'catch' the error, stash it and write handling code later +in your application: + + sub handle_unicode_encoding_exception { + my ($c, $params) = @_; + $c->stash(BAD_UNICODE_DATA=>$params); + # return a dummy string. + return 1; + } + +NOTE: Please keep in mind that once an error like this occurs, +the request setup is still ongoing, which means the state of C<$c> and +related context parts like the request and response may not be setup +up correctly (since we haven't finished the setup yet). If you throw +an exception the setup is aborted. =cut @@ -3541,13 +3630,13 @@ sub _handle_unicode_decoding { return unless defined $value; ## I think this mess is to support the old nested - if ( ref $value eq 'ARRAY' ) { + if ( is_plain_arrayref($value) ) { foreach ( @$value ) { $_ = $self->_handle_unicode_decoding($_); } return $value; } - elsif ( ref $value eq 'HASH' ) { + elsif ( is_plain_hashref($value) ) { foreach (keys %$value) { my $encoded_key = $self->_handle_param_unicode_decoding($_); $value->{$encoded_key} = $self->_handle_unicode_decoding($value->{$_}); @@ -3564,16 +3653,20 @@ sub _handle_unicode_decoding { } sub _handle_param_unicode_decoding { - my ( $self, $value ) = @_; + my ( $self, $value, $check ) = @_; return unless defined $value; # not in love with just ignoring undefs - jnap return $value if blessed($value); #don't decode when the value is an object. my $enc = $self->encoding; + + return $value unless $enc; # don't decode if no encoding is specified + + $check ||= $self->_encode_check; return try { - $enc->decode( $value, $self->_encode_check ); + $enc->decode( $value, $check); } catch { - $self->handle_unicode_encoding_exception({ + return $self->handle_unicode_encoding_exception({ param_value => $value, error_msg => $_, encoding_step => 'params', @@ -3876,9 +3969,9 @@ sub setup_middleware { if(ref $next) { if(Scalar::Util::blessed $next && $next->can('wrap')) { push @middleware, $next; - } elsif(ref $next eq 'CODE') { + } elsif(is_plain_coderef($next)) { push @middleware, $next; - } elsif(ref $next eq 'HASH') { + } elsif(is_plain_hashref($next)) { my $namespace = shift @middleware_definitions; my $mw = $class->Catalyst::Utils::build_middleware($namespace, %$next); push @middleware, $mw; @@ -4031,7 +4124,7 @@ We try each possible role in turn (and throw an error if none load) MyApp::TraitFor::Stats::Foo Catalyst::TraitFor::Stats::Foo -The namespace part 'TraitFor::Stats' was choosen to assist in backwards +The namespace part 'TraitFor::Stats' was chosen to assist in backwards compatibility with L which previously provided these features in a stand alone package. @@ -4245,7 +4338,7 @@ backwardly compatible). C -When creating body parameters from a POST, if we run into a multpart POST +When creating body parameters from a POST, if we run into a multipart POST that does not contain uploads, but instead contains inlined complex data (very uncommon) we cannot reliably convert that into field => value pairs. So instead we create an instance of L. If this causes @@ -4267,33 +4360,32 @@ parameter to true. 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 +request URL query or keywords. Most readings of the relevant 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 +will use, however 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 +This setting takes precedence over 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. +C -This setting take precedence over C. +Catalyst versions 5.90080 - 5.90106 would decode query parts of an incoming +request but would not raise an exception when the decoding failed due to +incorrect unicode. It now does, but if this change is giving you trouble +you may disable it by setting this configuration to true. =item * -C +C -Setting this to true will default your query decoding to whatever your -general global encoding is (the default is UTF-8). +By default we decode query and keywords in your request URL using UTF-8, which +is our reading of the relevant 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. =item * @@ -4319,19 +4411,19 @@ C - See L. C -An arrayref of Ls that get componsed into your stats class. +An arrayref of Ls that get composed into your stats class. =item * C -An arrayref of Ls that get componsed into your request class. +An arrayref of Ls that get composed into your request class. =item * C -An arrayref of Ls that get componsed into your response class. +An arrayref of Ls that get composed into your response class. =item * @@ -4810,6 +4902,8 @@ Caelum: Rafael Kitover chansen: Christian Hansen +Chase Venters C + chicks: Christopher Hicks Chisel Wright C