X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FEngine.pm;h=c5aacadd7cd1eec1f819f05904af1ab57d464fc5;hb=817ed8ab62b7b59cc37e82d67aa45824211f75f6;hp=349bc434b24949ea37a9a805d2e54c221dbbe4ef;hpb=568942951f418af5fbd97e4a94400adbb6aa19ff;p=catagits%2FCatalyst-Runtime.git

diff --git a/lib/Catalyst/Engine.pm b/lib/Catalyst/Engine.pm
index 349bc43..c5aacad 100644
--- a/lib/Catalyst/Engine.pm
+++ b/lib/Catalyst/Engine.pm
@@ -22,25 +22,6 @@ use namespace::clean -except => 'meta';
 # Amount of data to read from input on each pass
 our $CHUNKSIZE = 64 * 1024;
 
-# XXX - this is only here for compat, do not use!
-has env => ( is => 'rw', writer => '_set_env' );
-my $WARN_ABOUT_ENV = 0;
-around env => sub {
-  my ($orig, $self, @args) = @_;
-  if(@args) {
-    warn "env as a writer is deprecated, you probably need to upgrade Catalyst::Engine::PSGI"
-      unless $WARN_ABOUT_ENV++;
-    return $self->_set_env(@args);
-  }
-  return $self->$orig;
-};
-
-# XXX - Only here for Engine::PSGI compat
-sub prepare_connection {
-    my ($self, $ctx) = @_;
-    $ctx->request->prepare_connection;
-}
-
 =head1 NAME
 
 Catalyst::Engine - The Catalyst Engine
@@ -75,6 +56,7 @@ sub finalize_body {
     ## doing something custom and is expected to close the response
     return if $res->_has_write_fh;
 
+    my $body = $res->body; # save some typing
     if($res->_has_response_cb) {
         ## we have not called the response callback yet, so we are safe to send
         ## the whole body to PSGI
@@ -82,37 +64,55 @@ sub finalize_body {
         my @headers;
         $res->headers->scan(sub { push @headers, @_ });
 
-        ## We need to figure out what kind of body we have...
-        my $body = $res->body;
+        # We need to figure out what kind of body we have and normalize it to something
+        # PSGI can deal with
         if(defined $body) {
-            if( 
-                (blessed($body) && $body->can('getline'))
-                or ref($body) eq 'GLOB'
-            ) {
-              # Body is an IO handle that meets the PSGI spec
-            } elsif(blessed($body) && $body->can('read')) {
-                # 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.
+            # Handle objects first
+            if(blessed($body)) {
+                if($body->can('getline')) {
+                    # Body is an IO handle that meets the PSGI spec.  Nothing to normalize
+                } elsif($body->can('read')) {
+
+                    # 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 but someone could write a proxy
-                # object to wrap getline and proxy read
-                my $got;
-                do {
-                    $got = read $body, my ($buffer), $CHUNKSIZE;
-                    $got = 0 unless $self->write($c, $buffer );
-                } while $got > 0;
-
-                close $body;
-                return;
+                    # 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 
+                    # 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;
+                        $got = 0 unless $self->write($c, $buffer );
+                    } while $got > 0;
+
+                    close $body;
+                    return;
+                } else {
+                    # Looks like for  backcompat reasons we need to be able to deal
+                    # with stringyfiable objects.
+                    $body = ["$body"]; 
+                }
+            } elsif(ref $body) {
+                if( (ref($body) eq 'GLOB') or (ref($body) eq 'ARRAY')) {
+                  # Again, PSGI can just accept this, no transform needed.  We don't officially
+                  # document the body as arrayref at this time (and there's not specific test
+                  # cases.  we support it because it simplifies some plack compatibility logic
+                  # and we might make it official at some point.
+                } else {
+                   $c->log->error("${\ref($body)} is not a valid value for Response->body");
+                   return;
+                }
             } else {
-              # Looks like for  backcompat reasons we need to be able to deal
-              # with stringyfiable objects.
-              $body = "$body" if blessed($body); # Assume there's some sort of overloading..
-              $body = [$body];  
+                # Body is defined and not an object or reference.  We assume a simple value
+                # and wrap it in an array for PSGI
+                $body = [$body];
             }
         } else {
-          $body = [undef];
+            # There's no body...
+            $body = [];
         }
 
         $res->_response_cb->([ $res->status, \@headers, $body]);
@@ -128,11 +128,11 @@ sub finalize_body {
         ## We'll just use the old, existing code for this (or most of it)
 
         if(my $body = $res->body) {
-          no warnings 'uninitialized';
+
           if ( blessed($body) && $body->can('read') or ref($body) eq 'GLOB' ) {
 
               ## In this case we have no choice and will fall back on the old
-              ## manual streaming stuff.
+              ## manual streaming stuff.  Not optimal.  This is deprecated as of 5.900560+
 
               my $got;
               do {
@@ -143,6 +143,11 @@ sub finalize_body {
               close $body;
           }
           else {
+              
+              # Case where body was set afgter calling ->write.  We'd prefer not to
+              # support this, but I can see some use cases with the way most of the
+              # views work.
+
               $self->write($c, $body );
           }
         }
@@ -629,7 +634,6 @@ sub prepare_request {
     my ($self, $ctx, %args) = @_;
     $ctx->log->psgienv($args{env}) if $ctx->log->can('psgienv');
     $ctx->request->_set_env($args{env});
-    $self->_set_env($args{env}); # Nasty back compat!
     $ctx->response->_set_response_cb($args{response_cb});
 }