omg-actionpack 8.0.0.alpha1

data/lib/action_dispatch/http/response.rb

@@ -0,0 +1,556 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/module/attribute_accessors"
+require "action_dispatch/http/filter_redirect"
+require "action_dispatch/http/cache"
+require "monitor"
+
+module ActionDispatch # :nodoc:
+  # # Action Dispatch Response
+  #
+  # 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).
+  #
+  # The Response object for the current request is exposed on controllers as
+  # ActionController::Metal#response. ActionController::Metal also provides a few
+  # additional methods that delegate to attributes of the Response such as
+  # ActionController::Metal#headers.
+  #
+  # Integration tests will likely also want to inspect responses in more detail.
+  # Methods such as Integration::RequestHelpers#get and
+  # Integration::RequestHelpers#post return instances of TestResponse (which
+  # inherits from Response) for this purpose.
+  #
+  # 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
+    begin
+      # For `Rack::Headers` (Rack 3+):
+      require "rack/headers"
+      Headers = ::Rack::Headers
+    rescue LoadError
+      # For `Rack::Utils::HeaderHash`:
+      require "rack/utils"
+      Headers = ::Rack::Utils::HeaderHash
+    end
+
+    # To be deprecated:
+    Header = Headers
+
+    # The request that the response is responding to.
+    attr_accessor :request
+
+    # The HTTP status code.
+    attr_reader :status
+
+    # The headers for the response.
+    #
+    #     header["Content-Type"] # => "text/plain"
+    #     header["Content-Type"] = "application/json"
+    #     header["Content-Type"] # => "application/json"
+    #
+    # Also aliased as `headers`.
+    #
+    #     headers["Content-Type"] # => "text/plain"
+    #     headers["Content-Type"] = "application/json"
+    #     headers["Content-Type"] # => "application/json"
+    #
+    # Also aliased as `header` for compatibility.
+    attr_reader :headers
+
+    alias_method :header, :headers
+
+    delegate :[], :[]=, to: :@headers
+
+    def each(&block)
+      sending!
+      x = @stream.each(&block)
+      sent!
+      x
+    end
+
+    CONTENT_TYPE = "Content-Type"
+    SET_COOKIE   = "Set-Cookie"
+    NO_CONTENT_CODES = [100, 101, 102, 103, 204, 205, 304]
+
+    cattr_accessor :default_charset, default: "utf-8"
+    cattr_accessor :default_headers
+
+    include Rack::Response::Helpers
+    # Aliasing these off because AD::Http::Cache::Response defines them.
+    alias :_cache_control :cache_control
+    alias :_cache_control= :cache_control=
+
+    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 to_ary
+        @buf.respond_to?(:to_ary) ?
+          @buf.to_ary :
+          @buf.each
+      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
+      alias_method :<<, :write
+
+      def each(&block)
+        if @str_body
+          return enum_for(:each) unless block_given?
+
+          yield @str_body
+        else
+          each_chunk(&block)
+        end
+      end
+
+      def abort
+      end
+
+      def close
+        @response.commit!
+        @closed = true
+      end
+
+      def closed?
+        @closed
+      end
+
+      private
+        def each_chunk(&block)
+          @buf.each(&block)
+        end
+    end
+
+    def self.create(status = 200, headers = {}, body = [], default_headers: self.default_headers)
+      headers = merge_default_headers(headers, default_headers)
+      new status, headers, body
+    end
+
+    def self.merge_default_headers(original, default)
+      default.respond_to?(:merge) ? default.merge(original) : original
+    end
+
+    # The underlying body, as a streamable object.
+    attr_reader :stream
+
+    def initialize(status = 200, headers = nil, body = [])
+      super()
+
+      @headers = Headers.new
+
+      headers&.each do |key, value|
+        @headers[key] = value
+      end
+
+      self.body, self.status = body, status
+
+      @cv           = new_cond
+      @committed    = false
+      @sending      = false
+      @sent         = false
+
+      prepare_cache_control!
+
+      yield self if block_given?
+    end
+
+    def has_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
+
+    ##
+    # :method: location
+    #
+    # Location of the response.
+
+    ##
+    # :method: location=
+    #
+    # :call-seq: location=(location)
+    #
+    # Sets the location of the response
+
+    # Sets the HTTP status code.
+    def status=(status)
+      @status = Rack::Utils.status_code(status)
+    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=(content_type)
+      return unless content_type
+      new_header_info = parse_content_type(content_type.to_s)
+      prev_header_info = parsed_content_type_header
+      charset = new_header_info.charset || prev_header_info.charset
+      charset ||= self.class.default_charset unless prev_header_info.mime_type
+      set_content_type new_header_info.mime_type, charset
+    end
+
+    # Content type of response.
+    def content_type
+      super.presence
+    end
+
+    # Media type of response.
+    def media_type
+      parsed_content_type_header.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
+    # `default_charset`.
+    #
+    #     response.charset = 'utf-16' # => 'utf-16'
+    #     response.charset = nil      # => 'utf-8'
+    def charset=(charset)
+      content_type = parsed_content_type_header.mime_type
+      if false == charset
+        set_content_type content_type, nil
+      else
+        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 = parsed_content_type_header
+      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 `Net::HTTPResponse`.
+    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 `render`.
+    def body
+      @stream.body
+    end
+
+    def write(string)
+      @stream.write string
+    end
+
+    # Allows you to manually set or override the response body.
+    def body=(body)
+      if body.respond_to?(:to_path)
+        @stream = body
+      else
+        synchronize do
+          @stream = build_buffer self, munge_body_object(body)
+        end
+      end
+    end
+
+    # Avoid having to pass an open file handle as the response body. Rack::Sendfile
+    # will usually intercept the response and uses the path directly, so there is no
+    # reason to open the file.
+    class FileBody # :nodoc:
+      attr_reader :to_path
+
+      def initialize(path)
+        @to_path = path
+      end
+
+      def body
+        File.binread(to_path)
+      end
+
+      # Stream the file's contents if Rack::Sendfile isn't present.
+      def each
+        File.open(to_path, "rb") do |file|
+          while chunk = file.read(16384)
+            yield chunk
+          end
+        end
+      end
+    end
+
+    # Send the file stored at `path` as the response body.
+    def send_file(path)
+      commit!
+      @stream = FileBody.new(path)
+    end
+
+    def reset_body!
+      @stream = build_buffer(self, [])
+    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, @headers.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
+
+    CONTENT_TYPE_PARSER = /
+      \A
+      (?<mime_type>[^;\s]+\s*(?:;\s*(?:(?!charset)[^;\s])+)*)?
+      (?:;\s*charset=(?<quote>"?)(?<charset>[^;\s]+)\k<quote>)?
+    /x # :nodoc:
+
+    def parse_content_type(content_type)
+      if content_type && match = CONTENT_TYPE_PARSER.match(content_type)
+        ContentTypeHeader.new(match[:mime_type], match[:charset])
+      else
+        NullContentTypeHeader
+      end
+    end
+
+    # Small internal convenience method to get the parsed version of the current
+    # content type header.
+    def parsed_content_type_header
+      parse_content_type(get_header(CONTENT_TYPE))
+    end
+
+    def set_content_type(content_type, charset)
+      type = content_type || ""
+      type = "#{type}; charset=#{charset.to_s.downcase}" if charset
+      set_header CONTENT_TYPE, type
+    end
+
+    def before_committed
+      return if committed?
+      assign_default_content_type_and_charset!
+      merge_and_normalize_cache_control!(@cache_control)
+      handle_conditional_get!
+      handle_no_content!
+    end
+
+    def before_sending
+      # Normally we've already committed by now, but it's possible (e.g., if the
+      # controller action tries to read back its own response) to get here before
+      # that. In that case, we must force an "early" commit: we're about to freeze the
+      # headers, so this is our last chance.
+      commit! unless committed?
+
+      @request.commit_cookie_jar! unless committed?
+    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 media_type
+
+      ct = parsed_content_type_header
+      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 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
+
+      BODY_METHODS = { to_ary: true, each: true, call: true, to_path: true }
+
+      def respond_to?(method, include_private = false)
+        if BODY_METHODS.key?(method)
+          @response.stream.respond_to?(method)
+        else
+          super
+        end
+      end
+
+      def to_ary
+        @response.stream.to_ary
+      end
+
+      def each(*args, &block)
+        @response.each(*args, &block)
+      end
+
+      def call(*arguments, &block)
+        @response.stream.call(*arguments, &block)
+      end
+
+      def to_path
+        @response.stream.to_path
+      end
+    end
+
+    def handle_no_content!
+      if NO_CONTENT_CODES.include?(@status)
+        @headers.delete CONTENT_TYPE
+        @headers.delete "Content-Length"
+      end
+    end
+
+    def rack_response(status, headers)
+      if NO_CONTENT_CODES.include?(status)
+        [status, headers, []]
+      else
+        [status, headers, RackBody.new(self)]
+      end
+    end
+  end
+
+  ActiveSupport.run_load_hooks(:action_dispatch_response, Response)
+end

data/lib/action_dispatch/http/upload.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionDispatch
+  module Http
+    # # Action Dispatch HTTP UploadedFile
+    #
+    # Models uploaded files.
+    #
+    # The actual file is accessible via the `tempfile` accessor, though some of its
+    # interface is available directly for convenience.
+    #
+    # Uploaded files are temporary files whose lifespan is one request. When the
+    # object is finalized Ruby unlinks the file, so there is no need to clean them
+    # with a separate maintenance task.
+    class UploadedFile
+      # The basename of the file in the client.
+      attr_accessor :original_filename
+
+      # A string with the MIME type of the file.
+      attr_accessor :content_type
+
+      # A `Tempfile` object with the actual uploaded file. Note that some of its
+      # interface is available directly.
+      attr_accessor :tempfile
+
+      # A string with the headers of the multipart request.
+      attr_accessor :headers
+
+      def initialize(hash) # :nodoc:
+        @tempfile = hash[:tempfile]
+        raise(ArgumentError, ":tempfile is required") unless @tempfile
+
+        @content_type = hash[:type]
+
+        if hash[:filename]
+          @original_filename = hash[:filename].dup
+
+          begin
+            @original_filename.encode!(Encoding::UTF_8)
+          rescue EncodingError
+            @original_filename.force_encoding(Encoding::UTF_8)
+          end
+        else
+          @original_filename = nil
+        end
+
+        if hash[:head]
+          @headers = hash[:head].dup
+
+          begin
+            @headers.encode!(Encoding::UTF_8)
+          rescue EncodingError
+            @headers.force_encoding(Encoding::UTF_8)
+          end
+        else
+          @headers = nil
+        end
+      end
+
+      # Shortcut for `tempfile.read`.
+      def read(length = nil, buffer = nil)
+        @tempfile.read(length, buffer)
+      end
+
+      # Shortcut for `tempfile.open`.
+      def open
+        @tempfile.open
+      end
+
+      # Shortcut for `tempfile.close`.
+      def close(unlink_now = false)
+        @tempfile.close(unlink_now)
+      end
+
+      # Shortcut for `tempfile.path`.
+      def path
+        @tempfile.path
+      end
+
+      # Shortcut for `tempfile.to_path`.
+      def to_path
+        @tempfile.to_path
+      end
+
+      # Shortcut for `tempfile.rewind`.
+      def rewind
+        @tempfile.rewind
+      end
+
+      # Shortcut for `tempfile.size`.
+      def size
+        @tempfile.size
+      end
+
+      # Shortcut for `tempfile.eof?`.
+      def eof?
+        @tempfile.eof?
+      end
+
+      def to_io
+        @tempfile.to_io
+      end
+    end
+  end
+end