use Catalyst::Exception;
use Catalyst::Request::PartData;
use Moose;
+use Ref::Util qw(is_plain_arrayref is_plain_hashref);
use namespace::clean -except => 'meta';
# We copy, no references
foreach my $name (keys %$query_parameters) {
my $param = $query_parameters->{$name};
- $parameters->{$name} = ref $param eq 'ARRAY' ? [ @$param ] : $param;
+ $parameters->{$name} = is_plain_arrayref($param) ? [ @$param ] : $param;
}
# Merge query and body parameters
foreach my $name (keys %$body_parameters) {
my $param = $body_parameters->{$name};
- my @values = ref $param eq 'ARRAY' ? @$param : ($param);
+ my @values = is_plain_arrayref($param) ? @$param : ($param);
if ( my $existing = $parameters->{$name} ) {
- unshift(@values, (ref $existing eq 'ARRAY' ? @$existing : $existing));
+ unshift(@values, (is_plain_arrayref($existing) ? @$existing : $existing));
}
$parameters->{$name} = @values > 1 ? \@values : $values[0];
}
if(scalar %part_data && !$c->config->{skip_complex_post_part_handling}) {
foreach my $key (keys %part_data) {
my $proto_value = $part_data{$key};
- my ($val, @extra) = (ref($proto_value)||'') eq 'ARRAY' ? @$proto_value : ($proto_value);
+ my ($val, @extra) = is_plain_arrayref($proto_value) ? @$proto_value : ($proto_value);
+
+ $key = $c->_handle_param_unicode_decoding($key)
+ if ($c and $c->encoding and !$c->config->{skip_body_param_unicode_decoding});
if(@extra) {
- $params->{$key} = [map { Catalyst::Request::PartData->build_from_part_data($_) } ($val,@extra)];
+ $params->{$key} = [map { Catalyst::Request::PartData->build_from_part_data($c, $_) } ($val,@extra)];
} else {
- $params->{$key} = Catalyst::Request::PartData->build_from_part_data($val);
+ $params->{$key} = Catalyst::Request::PartData->build_from_part_data($c, $val);
}
}
} else {
$params = $self->_body->param;
- }
- # If we have an encoding configured (like UTF-8) in general we expect a client
- # to POST with the encoding we fufilled the request in. Otherwise don't do any
- # encoding (good change wide chars could be in HTML entity style llike the old
- # days -JNAP
+ # If we have an encoding configured (like UTF-8) in general we expect a client
+ # to POST with the encoding we fufilled the request in. Otherwise don't do any
+ # encoding (good change wide chars could be in HTML entity style llike the old
+ # days -JNAP
- # so, now that HTTP::Body prepared the body params, we gotta 'walk' the structure
- # and do any needed decoding.
+ # so, now that HTTP::Body prepared the body params, we gotta 'walk' the structure
+ # and do any needed decoding.
- # This only does something if the encoding is set via the encoding param. Remember
- # this is assuming the client is not bad and responds with what you provided. In
- # general you can just use utf8 and get away with it.
- #
- # I need to see if $c is here since this also doubles as a builder for the object :(
+ # This only does something if the encoding is set via the encoding param. Remember
+ # this is assuming the client is not bad and responds with what you provided. In
+ # general you can just use utf8 and get away with it.
+ #
+ # I need to see if $c is here since this also doubles as a builder for the object :(
- if($c and $c->encoding and !$c->config->{skip_body_param_unicode_decoding}) {
+ if($c and $c->encoding and !$c->config->{skip_body_param_unicode_decoding}) {
$params = $c->_handle_unicode_decoding($params);
+ }
}
my $return = $self->_use_hash_multivalue ?
These are the parameters from the POST part of the request, if any.
B<NOTE> If your POST is multipart, but contains non file upload parts (such
-as an line part with an alternative encoding or content type) we cannot determine
-the correct way to extra a meaningful value from the upload. In this case any
+as an line part with an alternative encoding or content type) we do our best to
+try and figure out how the value should be presented. If there's a specified character
+set we will use that to decode rather than the default encoding set by the application.
+However if there are complex headers and we cannot determine
+the correct way to extra a meaningful value from the upload, in this case any
part like this will be represented as an instance of L<Catalyst::Request::PartData>.
+Patches and review of this part of the code welcomed.
+
=head2 $req->body_params
Shortcut for body_parameters.
return wantarray ? () : undef;
}
- if ( ref $self->parameters->{$param} eq 'ARRAY' ) {
+ if ( is_plain_arrayref($self->parameters->{$param}) ) {
return (wantarray)
? @{ $self->parameters->{$param} }
: $self->parameters->{$param}->[0];
return wantarray ? () : undef;
}
- if ( ref $self->uploads->{$upload} eq 'ARRAY' ) {
+ if ( is_plain_arrayref($self->uploads->{$upload}) ) {
return (wantarray)
? @{ $self->uploads->{$upload} }
: $self->uploads->{$upload}->[0];
if ( exists $self->uploads->{$field} ) {
for ( $self->uploads->{$field} ) {
- $_ = [$_] unless ref($_) eq "ARRAY";
+ $_ = [$_] unless is_plain_arrayref($_);
push( @$_, $upload );
}
}
foreach my $value ( values %$args ) {
next unless defined $value;
- for ( ref $value eq 'ARRAY' ? @$value : $value ) {
+ for ( is_plain_arrayref($value) ? @$value : $value ) {
$_ = "$_";
# utf8::encode($_);
}
# an existing one regardless if the existing value is an array
# or not, and regardless if the new value is an array or not
$params{$key} = [
- ref($params{$key}) eq 'ARRAY' ? @{ $params{$key} } : $params{$key},
- ref($val) eq 'ARRAY' ? @{ $val } : $val
+ is_plain_arrayref($params{$key}) ? @{ $params{$key} } : $params{$key},
+ is_plain_arrayref($val) ? @{ $val } : $val
];
} else {
carp( 'No arguments passed to uri_with()' ) unless $args;
my $append = 0;
- if((ref($behavior) eq 'HASH') && defined($behavior->{mode}) && ($behavior->{mode} eq 'append')) {
+ if(is_plain_hashref($behavior) && defined($behavior->{mode}) && ($behavior->{mode} eq 'append')) {
$append = 1;
}
projects / catagits/Catalyst-Runtime.git / blobdiff