halorgium-actionpack 3.0.pre

data/lib/action_dispatch/http/response.rb

@@ -0,0 +1,290 @@
+require 'digest/md5'
+require 'active_support/core_ext/module/delegation'
+
+module ActionDispatch # :nodoc:
+  # Represents an HTTP response generated by a controller action. One can use
+  # an ActionDispatch::Response object to retrieve the current state
+  # of the response, or customize the response. An Response object can
+  # either represent a "real" HTTP response (i.e. one that is meant to be sent
+  # back to the web browser) or a test response (i.e. one that is generated
+  # from integration tests). See CgiResponse and TestResponse, respectively.
+  #
+  # Response is mostly a Ruby on Rails framework implement 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 < Rack::Response
+    attr_accessor :request, :blank
+    attr_reader :cache_control
+
+    attr_writer :header, :sending_file
+    alias_method :headers=, :header=
+
+    def initialize
+      @status = 200
+      @header = {}
+      @cache_control = {}
+
+      @writer = lambda { |x| @body << x }
+      @block = nil
+      @length = 0
+
+      @body, @cookie = [], []
+      @sending_file = false
+
+      yield self if block_given?
+    end
+
+    def cache_control
+      @cache_control ||= {}
+    end
+
+    def write(str)
+      s = str.to_s
+      @writer.call s
+      str
+    end
+
+    def status=(status)
+      @status = status.to_i
+    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
+
+    def message
+      StatusCodes::STATUS_CODES[@status]
+    end
+    alias_method :status_message, :message
+
+    def body
+      str = ''
+      each { |part| str << part.to_s }
+      str
+    end
+
+    EMPTY = " "
+
+    def body=(body)
+      @blank = true if body == EMPTY
+      @body = body.respond_to?(:to_str) ? [body] : body
+    end
+
+    def body_parts
+      @body
+    end
+
+    def location
+      headers['Location']
+    end
+    alias_method :redirect_url, :location
+
+    def location=(url)
+      headers['Location'] = url
+    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.
+    attr_accessor :charset, :content_type
+
+    def last_modified
+      if last = headers['Last-Modified']
+        Time.httpdate(last)
+      end
+    end
+
+    def last_modified?
+      headers.include?('Last-Modified')
+    end
+
+    def last_modified=(utc_time)
+      headers['Last-Modified'] = utc_time.httpdate
+    end
+
+    def etag
+      @etag
+    end
+
+    def etag?
+      @etag
+    end
+
+    def etag=(etag)
+      key = ActiveSupport::Cache.expand_cache_key(etag)
+      @etag = %("#{Digest::MD5.hexdigest(key)}")
+    end
+
+    CONTENT_TYPE    = "Content-Type"
+
+    cattr_accessor(:default_charset) { "utf-8" }
+
+    def assign_default_content_type_and_charset!
+      return if headers[CONTENT_TYPE].present?
+
+      @content_type ||= Mime::HTML
+      @charset      ||= self.class.default_charset
+
+      type = @content_type.to_s.dup
+      type << "; charset=#{@charset}" unless @sending_file
+
+      headers[CONTENT_TYPE] = type
+    end
+
+    def to_a
+      assign_default_content_type_and_charset!
+      handle_conditional_get!
+      self["Set-Cookie"] = @cookie.join("\n")
+      self["ETag"]       = @etag if @etag
+      super
+    end
+
+    alias prepare! to_a
+
+    def each(&callback)
+      if @body.respond_to?(:call)
+        @writer = lambda { |x| callback.call(x) }
+        @body.call(self, self)
+      else
+        @body.each { |part| callback.call(part.to_s) }
+      end
+
+      @writer = callback
+      @block.call(self) if @block
+    end
+
+    def write(str)
+      str = str.to_s
+      @writer.call str
+      str
+    end
+
+    # Returns the response cookies, converted to a Hash of (name => value) pairs
+    #
+    #   assert_equal 'AuthorOfNewPage', r.cookies['author']
+    def cookies
+      cookies = {}
+      if header = @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
+
+    def set_cookie(key, value)
+      case value
+      when Hash
+        domain  = "; domain="  + value[:domain]    if value[:domain]
+        path    = "; path="    + value[:path]      if value[:path]
+        # According to RFC 2109, we need dashes here.
+        # N.B.: cgi.rb uses spaces...
+        expires = "; expires=" + value[:expires].clone.gmtime.
+          strftime("%a, %d-%b-%Y %H:%M:%S GMT")    if value[:expires]
+        secure = "; secure"  if value[:secure]
+        httponly = "; HttpOnly" if value[:httponly]
+        value = value[:value]
+      end
+      value = [value]  unless Array === value
+      cookie = Rack::Utils.escape(key) + "=" +
+        value.map { |v| Rack::Utils.escape v }.join("&") +
+        "#{domain}#{path}#{expires}#{secure}#{httponly}"
+
+      @cookie << cookie
+    end
+
+    def delete_cookie(key, value={})
+      @cookie.reject! { |cookie|
+        cookie =~ /\A#{Rack::Utils.escape(key)}=/
+      }
+
+      set_cookie(key,
+                 {:value => '', :path => nil, :domain => nil,
+                   :expires => Time.at(0) }.merge(value))
+    end
+
+    private
+      def handle_conditional_get!
+        if etag? || last_modified? || !@cache_control.empty?
+          set_conditional_cache_control!
+        elsif nonempty_ok_response?
+          self.etag = @body
+
+          if request && request.etag_matches?(etag)
+            self.status = 304
+            self.body = []
+          end
+
+          set_conditional_cache_control!
+        else
+          headers["Cache-Control"] = "no-cache"
+        end
+      end
+
+      def nonempty_ok_response?
+        @status == 200 && string_body?
+      end
+
+      def string_body?
+        !@blank && @body.respond_to?(:all?) && @body.all? { |part| part.is_a?(String) }
+      end
+
+      DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate"
+
+      def set_conditional_cache_control!
+        control = @cache_control
+
+        if control.empty?
+          headers["Cache-Control"] = DEFAULT_CACHE_CONTROL
+        elsif @cache_control[:no_cache]
+          headers["Cache-Control"] = "no-cache"
+        else
+          extras  = control[:extras]
+          max_age = control[:max_age]
+
+          options = []
+          options << "max-age=#{max_age}" if max_age
+          options << (control[:public] ? "public" : "private")
+          options << "must-revalidate" if control[:must_revalidate]
+          options.concat(extras) if extras
+
+          headers["Cache-Control"] = options.join(", ")
+        end
+
+      end
+  end
+end

data/lib/action_dispatch/http/status_codes.rb

@@ -0,0 +1,42 @@
+require 'active_support/inflector'
+
+module ActionDispatch
+  module StatusCodes #:nodoc:
+    STATUS_CODES = Rack::Utils::HTTP_STATUS_CODES.merge({
+      102 => "Processing",
+      207 => "Multi-Status",
+      226 => "IM Used",
+      422 => "Unprocessable Entity",
+      423 => "Locked",
+      424 => "Failed Dependency",
+      426 => "Upgrade Required",
+      507 => "Insufficient Storage",
+      510 => "Not Extended"
+    }).freeze
+
+    # Provides a symbol-to-fixnum lookup for converting a symbol (like
+    # :created or :not_implemented) into its corresponding HTTP status
+    # code (like 200 or 501).
+    SYMBOL_TO_STATUS_CODE = STATUS_CODES.inject({}) { |hash, (code, message)|
+      hash[ActiveSupport::Inflector.underscore(message.gsub(/ /, "")).to_sym] = code
+      hash
+    }.freeze
+
+    private
+      # Given a status parameter, determine whether it needs to be converted
+      # to a string. If it is a fixnum, use the STATUS_CODES hash to lookup
+      # the default message. If it is a symbol, use the SYMBOL_TO_STATUS_CODE
+      # hash to convert it.
+      def interpret_status(status)
+        case status
+        when Fixnum then
+          "#{status} #{STATUS_CODES[status]}".strip
+        when Symbol then
+          interpret_status(SYMBOL_TO_STATUS_CODE[status] ||
+            "500 Unknown Status #{status.inspect}")
+        else
+          status.to_s
+        end
+      end
+  end
+end

data/lib/action_dispatch/http/utils.rb

@@ -0,0 +1,20 @@
+module ActionDispatch
+  module Utils
+    # TODO: Pull this into rack core
+    # http://github.com/halorgium/rack/commit/feaf071c1de743fbd10bc316830180a9af607278
+    def parse_config(config)
+      if config =~ /\.ru$/
+        cfgfile = ::File.read(config)
+        if cfgfile[/^#\\(.*)/]
+          opts.parse! $1.split(/\s+/)
+        end
+        inner_app = eval "Rack::Builder.new {( " + cfgfile + "\n )}.to_app",
+                         nil, config
+      else
+        require config
+        inner_app = Object.const_get(::File.basename(config, '.rb').capitalize)
+      end
+    end
+    module_function :parse_config
+  end
+end

data/lib/action_dispatch/middleware/callbacks.rb

@@ -0,0 +1,50 @@
+module ActionDispatch
+  class Callbacks
+    include ActiveSupport::Callbacks
+
+    define_callbacks :call, :terminator => "result == false", :rescuable => true
+    define_callbacks :prepare, :scope => :name
+
+    # Add a preparation callback. Preparation callbacks are run before every
+    # request in development mode, and before the first request in production mode.
+    #
+    # If a symbol with a block is given, the symbol is used as an identifier.
+    # That allows to_prepare to be called again with the same identifier to
+    # replace the existing callback. Passing an identifier is a suggested
+    # practice if the code adding a preparation block may be reloaded.
+    def self.to_prepare(*args, &block)
+      if args.first.is_a?(Symbol) && block_given?
+        define_method :"__#{args.first}", &block
+        set_callback(:prepare, :"__#{args.first}")
+      else
+        set_callback(:prepare, *args, &block)
+      end
+    end
+
+    def self.before(*args, &block)
+      set_callback(:call, :before, *args, &block)
+    end
+
+    def self.after(*args, &block)
+      set_callback(:call, :after, *args, &block)
+    end
+
+    class << self
+      # DEPRECATED
+      alias_method :before_dispatch, :before
+      alias_method :after_dispatch, :after
+    end
+
+    def initialize(app, prepare_each_request = false)
+      @app, @prepare_each_request = app, prepare_each_request
+      run_callbacks(:prepare)
+    end
+
+    def call(env)
+      run_callbacks(:call) do
+        run_callbacks(:prepare) if @prepare_each_request
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/action_dispatch/middleware/params_parser.rb

@@ -0,0 +1,79 @@
+require 'active_support/json'
+
+module ActionDispatch
+  class ParamsParser
+    DEFAULT_PARSERS = {
+      Mime::XML => :xml_simple,
+      Mime::JSON => :json
+    }
+
+    def initialize(app, parsers = {})
+      @app, @parsers = app, DEFAULT_PARSERS.merge(parsers)
+    end
+
+    def call(env)
+      if params = parse_formatted_parameters(env)
+        env["action_dispatch.request.request_parameters"] = params
+      end
+
+      @app.call(env)
+    end
+
+    private
+      def parse_formatted_parameters(env)
+        request = Request.new(env)
+
+        return false if request.content_length.zero?
+
+        mime_type = content_type_from_legacy_post_data_format_header(env) || request.content_type
+        strategy = @parsers[mime_type]
+
+        return false unless strategy
+
+        case strategy
+          when Proc
+            strategy.call(request.raw_post)
+          when :xml_simple, :xml_node
+            request.body.size == 0 ? {} : Hash.from_xml(request.body).with_indifferent_access
+          when :yaml
+            YAML.load(request.body)
+          when :json
+            if request.body.size == 0
+              {}
+            else
+              data = ActiveSupport::JSON.decode(request.body)
+              data = {:_json => data} unless data.is_a?(Hash)
+              data.with_indifferent_access
+            end
+          else
+            false
+        end
+      rescue Exception => e # YAML, XML or Ruby code block errors
+        logger.debug "Error occurred while parsing request parameters.\nContents:\n\n#{request.raw_post}"
+
+        raise
+          { "body" => request.raw_post,
+            "content_type" => request.content_type,
+            "content_length" => request.content_length,
+            "exception" => "#{e.message} (#{e.class})",
+            "backtrace" => e.backtrace }
+      end
+
+      def content_type_from_legacy_post_data_format_header(env)
+        if x_post_format = env['HTTP_X_POST_DATA_FORMAT']
+          case x_post_format.to_s.downcase
+            when 'yaml'
+              return Mime::YAML
+            when 'xml'
+              return Mime::XML
+          end
+        end
+
+        nil
+      end
+
+      def logger
+        defined?(Rails.logger) ? Rails.logger : Logger.new($stderr)
+      end
+  end
+end