aboutsummaryrefslogblamecommitdiffstats
path: root/actionpack/lib/action_dispatch/http/response.rb
blob: 45ffacd6f5352dc926448fa5bc473fd5ec3a34a3 (plain) (tree)
1
2
3
4
5
6
7
8
9
10
                                                            
                                              
                 
 
                               




                                                                                 
   
                                                                             



                                                                               
   
                                                                               
                                                                        
                                                

                                                                    
                                                              
   
                                                                           

                                       
                                                               

                                          
                           

          
                



                                                     
                       
 
                                    
                       
 


                                       
                                   
 


                                        
                                                     
 
                                                
                                    
 
                                   
                                                
                                                 
                        
 




                                   








                                                     




                                                 
                       




                         



                             

         


               









                         
                                                  

                       
                                                                                                     

             
                                                             
                      
 
                                           
 


                              

                           
 



                                
 




                                                   





                                     



                                              

                    
                        




                         





                       

       










                                                   
                                
                       
                                               

       
                                 
                                   
                                      
                                                                                           

       







                                                                                
 
                    
                                  





                            

       



                                                           
                                                
                         
                                      
                         
                                                      
          
                                            
                                                                            
         

       


                                                                         
                                      


                                                       
                                       
                     
             

       
                                                                               
            
                  

       

                                                                         




                                         
     
               
                                             
       
                                          
 
                                                                                 
                                      
            
                  
       
 

               
                                                               
                   
                                    
 


                                   


                                                              
         


                  


                                     

       
                                                   
                                         
 
             
                                                

       










                                                                       
                                                                             
                                          

                                         
            
             
                                            
       
                       
 




                                                                                
                                        






                                                                            



             
         
 
                                                       
                                                          
 

                                            

                                                          
                                 
                                            
          
                             



                                               
                                     



                                               
                        


                                              


                      

       
                                                
                                                                      

       







                                             
                                                
                            
 
                             

                                                                
       
 





























                                                                       



                

       
                                     
                                          
                                  
                                      

                            
                                            

         
     
   
require 'active_support/core_ext/module/attribute_accessors'
require 'action_dispatch/http/filter_redirect'
require 'monitor'

module ActionDispatch # :nodoc:
  # Represents an HTTP response generated by a controller action. Use it to
  # retrieve the current state of the response, or customize the response. It can
  # either represent a real HTTP response (i.e. one that is meant to be sent
  # back to the web browser) or a TestResponse (i.e. one that is generated
  # from integration tests).
  #
  # \Response is mostly a Ruby on \Rails framework implementation detail, and
  # should never be used directly in controllers. Controllers should use the
  # methods defined in ActionController::Base instead. For example, if you want
  # to set the HTTP response's content MIME type, then use
  # ActionControllerBase#headers instead of Response#headers.
  #
  # Nevertheless, integration tests may want to inspect controller responses in
  # more detail, and that's when \Response can be useful for application
  # developers. Integration test methods such as
  # ActionDispatch::Integration::Session#get and
  # ActionDispatch::Integration::Session#post return objects of type
  # TestResponse (which are of course also of type \Response).
  #
  # For example, the following demo integration test prints the body of the
  # controller response to the console:
  #
  #  class DemoControllerTest < ActionDispatch::IntegrationTest
  #    def test_print_root_path_to_console
  #      get('/')
  #      puts response.body
  #    end
  #  end
  class Response
    # The request that the response is responding to.
    attr_accessor :request

    # The HTTP status code.
    attr_reader :status

    # Get headers for this response.
    attr_reader :header

    alias_method :headers,  :header

    delegate :[], :[]=, :to => :@header
    delegate :each, :to => :@stream

    CONTENT_TYPE = "Content-Type".freeze
    SET_COOKIE   = "Set-Cookie".freeze
    LOCATION     = "Location".freeze
    NO_CONTENT_CODES = [100, 101, 102, 204, 205, 304]

    cattr_accessor(:default_charset) { "utf-8" }
    cattr_accessor(:default_headers)

    include Rack::Response::Helpers
    include ActionDispatch::Http::FilterRedirect
    include ActionDispatch::Http::Cache::Response
    include MonitorMixin

    class Buffer # :nodoc:
      def initialize(response, buf)
        @response = response
        @buf      = buf
        @closed   = false
        @str_body = nil
      end

      def body
        @str_body ||= begin
                        buf = ''
                        each { |chunk| buf << chunk }
                        buf
                      end
      end

      def write(string)
        raise IOError, "closed stream" if closed?

        @str_body = nil
        @response.commit!
        @buf.push string
      end

      def each(&block)
        @response.sending!
        x = @buf.each(&block)
        @response.sent!
        x
      end

      def abort
      end

      def close
        @response.commit!
        @closed = true
      end

      def closed?
        @closed
      end
    end

    # The underlying body, as a streamable object.
    attr_reader :stream

    def initialize(status = 200, header = {}, body = [], default_headers: self.class.default_headers)
      super()

      header = merge_default_headers(header, default_headers)
      @header = header

      self.body, self.status = body, status

      @blank        = false
      @cv           = new_cond
      @committed    = false
      @sending      = false
      @sent         = false

      prepare_cache_control!

      yield self if block_given?
    end

    def have_header?(key);  headers.key? key;   end
    def get_header(key);    headers[key];       end
    def set_header(key, v); headers[key] = v;   end
    def delete_header(key); headers.delete key; end

    def await_commit
      synchronize do
        @cv.wait_until { @committed }
      end
    end

    def await_sent
      synchronize { @cv.wait_until { @sent } }
    end

    def commit!
      synchronize do
        before_committed
        @committed = true
        @cv.broadcast
      end
    end

    def sending!
      synchronize do
        before_sending
        @sending = true
        @cv.broadcast
      end
    end

    def sent!
      synchronize do
        @sent = true
        @cv.broadcast
      end
    end

    def sending?;   synchronize { @sending };   end
    def committed?; synchronize { @committed }; end
    def sent?;      synchronize { @sent };      end

    # Sets the HTTP status code.
    def status=(status)
      @status = Rack::Utils.status_code(status)
    end

    # Sets the HTTP content type.
    def content_type=(content_type)
      header_info = parse_content_type
      set_content_type content_type.to_s, header_info.charset || self.class.default_charset
    end

    # Sets the HTTP response's content MIME type. For example, in the controller
    # you could write this:
    #
    #  response.content_type = "text/plain"
    #
    # If a character set has been defined for this response (see charset=) then
    # the character set information will also be included in the content type
    # information.

    def content_type
      parse_content_type.mime_type
    end

    def sending_file=(v)
      if true == v
        self.charset = false
      end
    end

    # Sets the HTTP character set. In case of nil parameter
    # it sets the charset to utf-8.
    #
    #   response.charset = 'utf-16' # => 'utf-16'
    #   response.charset = nil      # => 'utf-8'
    def charset=(charset)
      header_info = parse_content_type
      if false == charset
        set_header CONTENT_TYPE, header_info.mime_type
      else
        content_type = header_info.mime_type
        set_content_type content_type, charset || self.class.default_charset
      end
    end

    # The charset of the response. HTML wants to know the encoding of the
    # content you're giving them, so we need to send that along.
    def charset
      header_info = parse_content_type
      header_info.charset || self.class.default_charset
    end

    # The response code of the request.
    def response_code
      @status
    end

    # Returns a string to ensure compatibility with <tt>Net::HTTPResponse</tt>.
    def code
      @status.to_s
    end

    # Returns the corresponding message for the current HTTP status code:
    #
    #   response.status = 200
    #   response.message # => "OK"
    #
    #   response.status = 404
    #   response.message # => "Not Found"
    #
    def message
      Rack::Utils::HTTP_STATUS_CODES[@status]
    end
    alias_method :status_message, :message

    # Returns the content of the response as a string. This contains the contents
    # of any calls to <tt>render</tt>.
    def body
      @stream.body
    end

    EMPTY = " "

    # Allows you to manually set or override the response body.
    def body=(body)
      @blank = true if body == EMPTY

      if body.respond_to?(:to_path)
        @stream = body
      else
        synchronize do
          @stream = build_buffer self, munge_body_object(body)
        end
      end
    end

    def body_parts
      parts = []
      @stream.each { |x| parts << x }
      parts
    end

    # The location header we'll be responding with.
    alias_method :redirect_url, :location

    def close
      stream.close if stream.respond_to?(:close)
    end

    def abort
      if stream.respond_to?(:abort)
        stream.abort
      elsif stream.respond_to?(:close)
        # `stream.close` should really be reserved for a close from the
        # other direction, but we must fall back to it for
        # compatibility.
        stream.close
      end
    end

    # Turns the Response into a Rack-compatible array of the status, headers,
    # and body. Allows explicit splatting:
    #
    #   status, headers, body = *response
    def to_a
      commit!
      rack_response @status, @header.to_hash
    end
    alias prepare! to_a

    # Returns the response cookies, converted to a Hash of (name => value) pairs
    #
    #   assert_equal 'AuthorOfNewPage', r.cookies['author']
    def cookies
      cookies = {}
      if header = get_header(SET_COOKIE)
        header = header.split("\n") if header.respond_to?(:to_str)
        header.each do |cookie|
          if pair = cookie.split(';').first
            key, value = pair.split("=").map { |v| Rack::Utils.unescape(v) }
            cookies[key] = value
          end
        end
      end
      cookies
    end

  private

    ContentTypeHeader = Struct.new :mime_type, :charset
    NullContentTypeHeader = ContentTypeHeader.new nil, nil

    def parse_content_type
      content_type = get_header CONTENT_TYPE
      if content_type
        type, charset = content_type.split(/;\s*charset=/)
        type = nil if type.empty?
        ContentTypeHeader.new(type, charset)
      else
        NullContentTypeHeader
      end
    end

    def set_content_type(content_type, charset)
      type = (content_type || '').dup
      type << "; charset=#{charset}" if charset
      set_header CONTENT_TYPE, type
    end

    def before_committed
      return if committed?
      assign_default_content_type_and_charset!
      handle_conditional_get!
    end

    def before_sending
    end

    def merge_default_headers(original, default)
      default.respond_to?(:merge) ? default.merge(original) : original
    end

    def build_buffer(response, body)
      Buffer.new response, body
    end

    def munge_body_object(body)
      body.respond_to?(:each) ? body : [body]
    end

    def assign_default_content_type_and_charset!
      return if content_type

      ct = parse_content_type
      set_content_type(ct.mime_type || Mime::HTML.to_s,
                       ct.charset || self.class.default_charset)
    end

    class RackBody
      def initialize(response)
        @response = response
      end

      def each(*args, &block)
        @response.each(*args, &block)
      end

      def close
        # Rack "close" maps to Response#abort, and *not* Response#close
        # (which is used when the controller's finished writing)
        @response.abort
      end

      def body
        @response.body
      end

      def respond_to?(method, include_private = false)
        if method.to_s == 'to_path'
          @response.stream.respond_to?(method)
        else
          super
        end
      end

      def to_path
        @response.stream.to_path
      end

      def to_ary
        nil
      end
    end

    def rack_response(status, header)
      if NO_CONTENT_CODES.include?(status)
        header.delete CONTENT_TYPE
        header.delete 'Content-Length'
        [status, header, []]
      else
        [status, header, RackBody.new(self)]
      end
    end
  end
end