update distar url

[catagits/Catalyst-Runtime.git] / lib / Catalyst / Engine.pm

diff --git a/lib/Catalyst/Engine.pm b/lib/Catalyst/Engine.pm
index 5e87e9f..a77c730 100644 (file)
--- a/lib/Catalyst/Engine.pm
+++ b/lib/Catalyst/Engine.pm
@@ -76,7 +76,7 @@ sub finalize_body {
     if($res->_has_response_cb) {
         ## we have not called the response callback yet, so we are safe to send
         ## the whole body to PSGI
-        
+
         my @headers;
         $res->headers->scan(sub { push @headers, @_ });
 
@@ -92,12 +92,12 @@ sub finalize_body {
                     # In the past, Catalyst only looked for ->read not ->getline.  It is very possible
                     # that one might have an object that respected read but did not have getline.
                     # As a result, we need to handle this case for backcompat.
-                
+
                     # We will just do the old loop for now.  In a future version of Catalyst this support
-                    # will be removed and one will have to rewrite their custom object or use 
+                    # will be removed and one will have to rewrite their custom object or use
                     # Plack::Middleware::AdaptFilehandleRead.  In anycase support for this is officially
                     # deprecated and described as such as of 5.90060
-                   
+
                     my $got;
                     do {
                         $got = read $body, my ($buffer), $CHUNKSIZE;
@@ -109,7 +109,7 @@ sub finalize_body {
                 } else {
                     # Looks like for  backcompat reasons we need to be able to deal
                     # with stringyfiable objects.
-                    $body = ["$body"]; 
+                    $body = ["$body"];
                 }
             } elsif(ref $body) {
                 if( (ref($body) eq 'GLOB') or (ref($body) eq 'ARRAY')) {
@@ -139,7 +139,7 @@ sub finalize_body {
         ## for backcompat we still need to handle a ->body.  I guess I could see
         ## someone calling ->write to presend some stuff, and then doing the rest
         ## via ->body, like in a template.
-        
+
         ## We'll just use the old, existing code for this (or most of it)
 
         if(my $body = $res->body) {
@@ -158,7 +158,7 @@ sub finalize_body {
               close $body;
           }
           else {
-              
+
               # Case where body was set after calling ->write.  We'd prefer not to
               # support this, but I can see some use cases with the way most of the
               # views work. Since body has already been encoded, we need to do
@@ -202,6 +202,7 @@ sub finalize_cookies {
                 -path    => $val->{path},
                 -secure  => $val->{secure} || 0,
                 -httponly => $val->{httponly} || 0,
+                -samesite => $val->{samesite},
             )
         );
         if (!defined $cookie) {
@@ -249,7 +250,7 @@ sub finalize_error {
 
     $c->res->content_type('text/html; charset=utf-8');
     my $name = ref($c)->config->{name} || join(' ', split('::', ref $c));
-    
+
     # Prevent Catalyst::Plugin::Unicode::Encoding from running.
     # This is a little nasty, but it's the best way to be clean whether or
     # not the user has an encoding plugin.
@@ -574,38 +575,48 @@ sub prepare_query_parameters {
     my ($self, $c) = @_;
     my $env = $c->request->env;
     my $do_not_decode_query = $c->config->{do_not_decode_query};
-    my $default_query_encoding = $c->config->{default_query_encoding} || 
-      ($c->config->{decode_query_using_global_encoding} ?
-        $c->encoding : 'UTF-8');
 
+    my $old_encoding;
+    if(my $new = $c->config->{default_query_encoding}) {
+      $old_encoding = $c->encoding;
+      $c->encoding($new);
+    }
+
+    my $check = $c->config->{do_not_check_query_encoding} ? undef :$c->_encode_check;
     my $decoder = sub {
       my $str = shift;
       return $str if $do_not_decode_query;
-      return $str unless $default_query_encoding;
-      return decode( $default_query_encoding, $str);
+      return $c->_handle_param_unicode_decoding($str, $check);
     };
 
     my $query_string = exists $env->{QUERY_STRING}
         ? $env->{QUERY_STRING}
         : '';
 
-    # Check for keywords (no = signs)
-    # (yes, index() is faster than a regex :))
-    if ( index( $query_string, '=' ) < 0 ) {
-        my $keywords = $self->unescape_uri($query_string);
-        $keywords = $decoder->($keywords);
-        $c->request->query_keywords($keywords);
-        return;
-    }
-
     $query_string =~ s/\A[&;]+//;
 
-    my $p = Hash::MultiValue->new(
-        map { defined $_ ? $decoder->($self->unescape_uri($_)) : $_ }
-        map { ( split /=/, $_, 2 )[0,1] } # slice forces two elements
-        split /[&;]+/, $query_string
-    );
+    my @unsplit_pairs = split /[&;]+/, $query_string;
+    my $p = Hash::MultiValue->new();
 
+    my $is_first_pair = 1;
+    for my $pair (@unsplit_pairs) {
+        my ($name, $value)
+          = map { defined $_ ? $decoder->($self->unescape_uri($_)) : $_ }
+            ( split /=/, $pair, 2 )[0,1]; # slice forces two elements
+
+        if ($is_first_pair) {
+            # If the first pair has no equal sign, then it means the isindex
+            # flag is set.
+            $c->request->query_keywords($name) unless defined $value;
+
+            $is_first_pair = 0;
+        }
+
+        $p->add( $name => $value );
+    }
+
+
+    $c->encoding($old_encoding) if $old_encoding;
     $c->request->query_parameters( $c->request->_use_hash_multivalue ? $p : $p->mixed );
 }
 
@@ -650,8 +661,8 @@ sub prepare_uploads {
     my $uploads = $request->_body->upload;
     my $parameters = $request->parameters;
     foreach my $name (keys %$uploads) {
-        $name = $c->_handle_unicode_decoding($name) if $enc;
         my $files = $uploads->{$name};
+        $name = $c->_handle_unicode_decoding($name) if $enc;
         my @uploads;
         for my $upload (ref $files eq 'ARRAY' ? @$files : ($files)) {
             my $headers = HTTP::Headers->new( %{ $upload->{headers} } );