actionpack 4.2.10 → 5.0.0

data/lib/action_dispatch/middleware/debug_exceptions.rb

@@ -1,6 +1,10 @@
 require 'action_dispatch/http/request'
 require 'action_dispatch/middleware/exception_wrapper'
 require 'action_dispatch/routing/inspector'
+require 'action_view'
+require 'action_view/base'
+
+require 'pp'
 
 module ActionDispatch
   # This middleware is responsible for logging exceptions and
@@ -8,12 +12,40 @@ module ActionDispatch
   class DebugExceptions
     RESCUES_TEMPLATE_PATH = File.expand_path('../templates', __FILE__)
 
-    def initialize(app, routes_app = nil)
-      @app        = app
-      @routes_app = routes_app
+    class DebugView < ActionView::Base
+      def debug_params(params)
+        clean_params = params.clone
+        clean_params.delete("action")
+        clean_params.delete("controller")
+
+        if clean_params.empty?
+          'None'
+        else
+          PP.pp(clean_params, "", 200)
+        end
+      end
+
+      def debug_headers(headers)
+        if headers.present?
+          headers.inspect.gsub(',', ",\n")
+        else
+          'None'
+        end
+      end
+
+      def debug_hash(object)
+        object.to_hash.sort_by { |k, _| k.to_s }.map { |k, v| "#{k}: #{v.inspect rescue $!.message}" }.join("\n")
+      end
+    end
+
+    def initialize(app, routes_app = nil, response_format = :default)
+      @app             = app
+      @routes_app      = routes_app
+      @response_format = response_format
     end
 
     def call(env)
+      request = ActionDispatch::Request.new env
       _, headers, body = response = @app.call(env)
 
       if headers['X-Cascade'] == 'pass'
@@ -23,61 +55,99 @@ module ActionDispatch
 
       response
     rescue Exception => exception
-      raise exception if env['action_dispatch.show_exceptions'] == false
-      render_exception(env, exception)
+      raise exception unless request.show_exceptions?
+      render_exception(request, exception)
     end
 
     private
 
-    def render_exception(env, exception)
-      wrapper = ExceptionWrapper.new(env, exception)
-      log_error(env, wrapper)
-
-      if env['action_dispatch.show_detailed_exceptions']
-        request = Request.new(env)
-        traces = wrapper.traces
-
-        trace_to_show = 'Application Trace'
-        if traces[trace_to_show].empty? && wrapper.rescue_template != 'routing_error'
-          trace_to_show = 'Full Trace'
+    def render_exception(request, exception)
+      backtrace_cleaner = request.get_header('action_dispatch.backtrace_cleaner')
+      wrapper = ExceptionWrapper.new(backtrace_cleaner, exception)
+      log_error(request, wrapper)
+
+      if request.get_header('action_dispatch.show_detailed_exceptions')
+        case @response_format
+        when :api
+          render_for_api_application(request, wrapper)
+        when :default
+          render_for_default_application(request, wrapper)
         end
+      else
+        raise exception
+      end
+    end
 
-        if source_to_show = traces[trace_to_show].first
-          source_to_show_id = source_to_show[:id]
-        end
+    def render_for_default_application(request, wrapper)
+      template = create_template(request, wrapper)
+      file = "rescues/#{wrapper.rescue_template}"
 
-        template = ActionView::Base.new([RESCUES_TEMPLATE_PATH],
-          request: request,
-          exception: wrapper.exception,
-          traces: traces,
-          show_source_idx: source_to_show_id,
-          trace_to_show: trace_to_show,
-          routes_inspector: routes_inspector(exception),
-          source_extracts: wrapper.source_extracts,
-          line_number: wrapper.line_number,
-          file: wrapper.file
-        )
-        file = "rescues/#{wrapper.rescue_template}"
-
-        if request.xhr?
-          body = template.render(template: file, layout: false, formats: [:text])
-          format = "text/plain"
-        else
-          body = template.render(template: file, layout: 'rescues/layout')
-          format = "text/html"
-        end
-        render(wrapper.status_code, body, format)
+      if request.xhr?
+        body = template.render(template: file, layout: false, formats: [:text])
+        format = "text/plain"
       else
-        raise exception
+        body = template.render(template: file, layout: 'rescues/layout')
+        format = "text/html"
+      end
+      render(wrapper.status_code, body, format)
+    end
+
+    def render_for_api_application(request, wrapper)
+      body = {
+        status: wrapper.status_code,
+        error:  Rack::Utils::HTTP_STATUS_CODES.fetch(
+          wrapper.status_code,
+          Rack::Utils::HTTP_STATUS_CODES[500]
+        ),
+        exception: wrapper.exception.inspect,
+        traces: wrapper.traces
+      }
+
+      content_type = request.formats.first
+      to_format = "to_#{content_type.to_sym}"
+
+      if content_type && body.respond_to?(to_format)
+        formatted_body = body.public_send(to_format)
+        format = content_type
+      else
+        formatted_body = body.to_json
+        format = Mime[:json]
+      end
+
+      render(wrapper.status_code, formatted_body, format)
+    end
+
+    def create_template(request, wrapper)
+      traces = wrapper.traces
+
+      trace_to_show = 'Application Trace'
+      if traces[trace_to_show].empty? && wrapper.rescue_template != 'routing_error'
+        trace_to_show = 'Full Trace'
       end
+
+      if source_to_show = traces[trace_to_show].first
+        source_to_show_id = source_to_show[:id]
+      end
+
+      DebugView.new([RESCUES_TEMPLATE_PATH],
+        request: request,
+        exception: wrapper.exception,
+        traces: traces,
+        show_source_idx: source_to_show_id,
+        trace_to_show: trace_to_show,
+        routes_inspector: routes_inspector(wrapper.exception),
+        source_extracts: wrapper.source_extracts,
+        line_number: wrapper.line_number,
+        file: wrapper.file
+      )
     end
 
     def render(status, body, format)
       [status, {'Content-Type' => "#{format}; charset=#{Response.default_charset}", 'Content-Length' => body.bytesize.to_s}, [body]]
     end
 
-    def log_error(env, wrapper)
-      logger = logger(env)
+    def log_error(request, wrapper)
+      logger = logger(request)
       return unless logger
 
       exception = wrapper.exception
@@ -86,15 +156,20 @@ module ActionDispatch
       trace = wrapper.framework_trace if trace.empty?
 
       ActiveSupport::Deprecation.silence do
-        message = "\n#{exception.class} (#{exception.message}):\n"
-        message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
-        message << "  " << trace.join("\n  ")
-        logger.fatal("#{message}\n\n")
+        logger.fatal "  "
+        logger.fatal "#{exception.class} (#{exception.message}):"
+        log_array logger, exception.annoted_source_code if exception.respond_to?(:annoted_source_code)
+        logger.fatal "  "
+        log_array logger, trace
       end
     end
 
-    def logger(env)
-      env['action_dispatch.logger'] || stderr_logger
+    def log_array(logger, array)
+      array.map { |line| logger.fatal line }
+    end
+
+    def logger(request)
+      request.logger || ActionView::Base.logger || stderr_logger
     end
 
     def stderr_logger

data/lib/action_dispatch/middleware/exception_wrapper.rb

@@ -1,5 +1,5 @@
-require 'action_controller/metal/exceptions'
 require 'active_support/core_ext/module/attribute_accessors'
+require 'rack/utils'
 
 module ActionDispatch
   class ExceptionWrapper
@@ -16,7 +16,9 @@ module ActionDispatch
       'ActionController::InvalidCrossOriginRequest'   => :unprocessable_entity,
       'ActionDispatch::ParamsParser::ParseError'      => :bad_request,
       'ActionController::BadRequest'                  => :bad_request,
-      'ActionController::ParameterMissing'            => :bad_request
+      'ActionController::ParameterMissing'            => :bad_request,
+      'Rack::Utils::ParameterTypeError'               => :bad_request,
+      'Rack::Utils::InvalidParameterError'            => :bad_request
     )
 
     cattr_accessor :rescue_templates
@@ -28,13 +30,13 @@ module ActionDispatch
       'ActionView::Template::Error'         => 'template_error'
     )
 
-    attr_reader :env, :exception, :line_number, :file
+    attr_reader :backtrace_cleaner, :exception, :line_number, :file
 
-    def initialize(env, exception)
-      @env = env
+    def initialize(backtrace_cleaner, exception)
+      @backtrace_cleaner = backtrace_cleaner
       @exception = original_exception(exception)
 
-      expand_backtrace if exception.is_a?(SyntaxError) || exception.try(:original_exception).try(:is_a?, SyntaxError)
+      expand_backtrace if exception.is_a?(SyntaxError) || exception.cause.is_a?(SyntaxError)
     end
 
     def rescue_template
@@ -58,7 +60,7 @@ module ActionDispatch
     end
 
     def traces
-      appplication_trace_with_ids = []
+      application_trace_with_ids = []
       framework_trace_with_ids = []
       full_trace_with_ids = []
 
@@ -66,7 +68,7 @@ module ActionDispatch
         trace_with_id = { id: idx, trace: trace }
 
         if application_trace.include?(trace)
-          appplication_trace_with_ids << trace_with_id
+          application_trace_with_ids << trace_with_id
         else
           framework_trace_with_ids << trace_with_id
         end
@@ -75,7 +77,7 @@ module ActionDispatch
       end
 
       {
-        "Application Trace" => appplication_trace_with_ids,
+        "Application Trace" => application_trace_with_ids,
         "Framework Trace" => framework_trace_with_ids,
         "Full Trace" => full_trace_with_ids
       }
@@ -87,8 +89,7 @@ module ActionDispatch
 
     def source_extracts
       backtrace.map do |trace|
-        file, line = trace.split(":")
-        line_number = line.to_i
+        file, line_number = extract_file_and_line_number(trace)
 
         {
           code: source_fragment(file, line_number),
@@ -104,17 +105,13 @@ module ActionDispatch
     end
 
     def original_exception(exception)
-      if registered_original_exception?(exception)
-        exception.original_exception
+      if @@rescue_responses.has_key?(exception.cause.class.name)
+        exception.cause
       else
         exception
       end
     end
 
-    def registered_original_exception?(exception)
-      exception.respond_to?(:original_exception) && @@rescue_responses.has_key?(exception.original_exception.class.name)
-    end
-
     def clean_backtrace(*args)
       if backtrace_cleaner
         backtrace_cleaner.clean(backtrace, *args)
@@ -123,10 +120,6 @@ module ActionDispatch
       end
     end
 
-    def backtrace_cleaner
-      @backtrace_cleaner ||= @env['action_dispatch.backtrace_cleaner']
-    end
-
     def source_fragment(path, line)
       return unless Rails.respond_to?(:root) && Rails.root
       full_path = Rails.root.join(path)
@@ -139,6 +132,13 @@ module ActionDispatch
       end
     end
 
+    def extract_file_and_line_number(trace)
+      # Split by the first colon followed by some digits, which works for both
+      # Windows and Unix path styles.
+      file, line = trace.match(/^(.+?):(\d+).*$/, &:captures) || trace
+      [file, line.to_i]
+    end
+
     def expand_backtrace
       @exception.backtrace.unshift(
         @exception.to_s.split("\n")

data/lib/action_dispatch/middleware/executor.rb

@@ -0,0 +1,19 @@
+require 'rack/body_proxy'
+
+module ActionDispatch
+  class Executor
+    def initialize(app, executor)
+      @app, @executor = app, executor
+    end
+
+    def call(env)
+      state = @executor.run!
+      begin
+        response = @app.call(env)
+        returned = response << ::Rack::BodyProxy.new(response.pop) { state.complete! }
+      ensure
+        state.complete! unless returned
+      end
+    end
+  end
+end

data/lib/action_dispatch/middleware/flash.rb

@@ -1,15 +1,6 @@
 require 'active_support/core_ext/hash/keys'
 
 module ActionDispatch
-  class Request < Rack::Request
-    # Access the contents of the flash. Use <tt>flash["notice"]</tt> to
-    # read a notice you put there or <tt>flash["notice"] = "hello"</tt>
-    # to put a new one.
-    def flash
-      @env[Flash::KEY] ||= Flash::FlashHash.from_session_value(session["flash"])
-    end
-  end
-
   # The flash provides a way to pass temporary primitive-types (String, Array, Hash) between actions. Anything you place in the flash will be exposed
   # to the very next action and then cleared out. This is a great way of doing notices and alerts, such as a create
   # action that sets <tt>flash[:notice] = "Post successfully created"</tt> before redirecting to a display action that can
@@ -47,6 +38,45 @@ module ActionDispatch
   class Flash
     KEY = 'action_dispatch.request.flash_hash'.freeze
 
+    module RequestMethods
+      # Access the contents of the flash. Use <tt>flash["notice"]</tt> to
+      # read a notice you put there or <tt>flash["notice"] = "hello"</tt>
+      # to put a new one.
+      def flash
+        flash = flash_hash
+        return flash if flash
+        self.flash = Flash::FlashHash.from_session_value(session["flash"])
+      end
+
+      def flash=(flash)
+        set_header Flash::KEY, flash
+      end
+
+      def flash_hash # :nodoc:
+        get_header Flash::KEY
+      end
+
+      def commit_flash # :nodoc:
+        session    = self.session || {}
+        flash_hash = self.flash_hash
+
+        if flash_hash && (flash_hash.present? || session.key?('flash'))
+          session["flash"] = flash_hash.to_session_value
+          self.flash = flash_hash.dup
+        end
+
+        if (!session.respond_to?(:loaded?) || session.loaded?) && # (reset_session uses {}, which doesn't implement #loaded?)
+            session.key?('flash') && session['flash'].nil?
+          session.delete('flash')
+        end
+      end
+
+      def reset_session # :nodoc
+        super
+        self.flash = nil
+      end
+    end
+
     class FlashNow #:nodoc:
       attr_accessor :flash
 
@@ -80,24 +110,30 @@ module ActionDispatch
       include Enumerable
 
       def self.from_session_value(value) #:nodoc:
-        flash = case value
-                when FlashHash # Rails 3.1, 3.2
-                  new(value.instance_variable_get(:@flashes), value.instance_variable_get(:@used))
-                when Hash # Rails 4.0
-                  new(value['flashes'], value['discard'])
-                else
-                  new
-                end
-
-        flash.tap(&:sweep)
-      end
-      
-      # Builds a hash containing the discarded values and the hashes
-      # representing the flashes.
-      # If there are no values in @flashes, returns nil.
+        case value
+        when FlashHash # Rails 3.1, 3.2
+          flashes = value.instance_variable_get(:@flashes)
+          if discard = value.instance_variable_get(:@used)
+            flashes.except!(*discard)
+          end
+          new(flashes, flashes.keys)
+        when Hash # Rails 4.0
+          flashes = value['flashes']
+          if discard = value['discard']
+            flashes.except!(*discard)
+          end
+          new(flashes, flashes.keys)
+        else
+          new
+        end
+      end
+
+      # Builds a hash containing the flashes to keep for the next request.
+      # If there are none to keep, returns nil.
       def to_session_value #:nodoc:
-        return nil if empty?
-        {'discard' => @discard.to_a, 'flashes' => @flashes}
+        flashes_to_keep = @flashes.except(*@discard)
+        return nil if flashes_to_keep.empty?
+        { 'discard' => [], 'flashes' => flashes_to_keep }
       end
 
       def initialize(flashes = {}, discard = []) #:nodoc:
@@ -252,25 +288,10 @@ module ActionDispatch
       end
     end
 
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      @app.call(env)
-    ensure
-      session    = Request::Session.find(env) || {}
-      flash_hash = env[KEY]
-
-      if flash_hash && (flash_hash.present? || session.key?('flash'))
-        session["flash"] = flash_hash.to_session_value
-        env[KEY] = flash_hash.dup
-      end
+    def self.new(app) app; end
+  end
 
-      if (!session.respond_to?(:loaded?) || session.loaded?) && # (reset_session uses {}, which doesn't implement #loaded?)
-        session.key?('flash') && session['flash'].nil?
-        session.delete('flash')
-      end
-    end
+  class Request
+    prepend Flash::RequestMethods
   end
 end

data/lib/action_dispatch/middleware/params_parser.rb

@@ -1,60 +1,46 @@
-require 'active_support/core_ext/hash/conversions'
 require 'action_dispatch/http/request'
-require 'active_support/core_ext/hash/indifferent_access'
 
 module ActionDispatch
+  # ActionDispatch::ParamsParser works for all the requests having any Content-Length
+  # (like POST). It takes raw data from the request and puts it through the parser
+  # that is picked based on Content-Type header.
+  #
+  # In case of any error while parsing data ParamsParser::ParseError is raised.
   class ParamsParser
+    # Raised when raw data from the request cannot be parsed by the parser
+    # defined for request's content mime type.
     class ParseError < StandardError
-      attr_reader :original_exception
 
-      def initialize(message, original_exception)
-        super(message)
-        @original_exception = original_exception
-      end
-    end
-
-    DEFAULT_PARSERS = { 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?
-
-        strategy = @parsers[request.content_mime_type]
-
-        return false unless strategy
+      def initialize(message = nil, original_exception = nil)
+        if message
+          ActiveSupport::Deprecation.warn("Passing #message is deprecated and has no effect. " \
+                                          "#{self.class} will automatically capture the message " \
+                                          "of the original exception.", caller)
+        end
 
-        case strategy
-        when Proc
-          strategy.call(request.raw_post)
-        when :json
-          data = ActiveSupport::JSON.decode(request.raw_post)
-          data = {:_json => data} unless data.is_a?(Hash)
-          Request::Utils.deep_munge(data).with_indifferent_access
-        else
-          false
+        if original_exception
+          ActiveSupport::Deprecation.warn("Passing #original_exception is deprecated and has no effect. " \
+                                          "Exceptions will automatically capture the original exception.", caller)
         end
-      rescue => e # JSON or Ruby code block errors
-        logger(env).debug "Error occurred while parsing request parameters.\nContents:\n\n#{request.raw_post}"
 
-        raise ParseError.new(e.message, e)
+        super($!.message)
       end
 
-      def logger(env)
-        env['action_dispatch.logger'] || ActiveSupport::Logger.new($stderr)
+      def original_exception
+        ActiveSupport::Deprecation.warn("#original_exception is deprecated. Use #cause instead.", caller)
+        cause
       end
+    end
+
+    # Create a new +ParamsParser+ middleware instance.
+    #
+    # The +parsers+ argument can take Hash of parsers where key is identifying
+    # content mime type, and value is a lambda that is going to process data.
+    def self.new(app, parsers = {})
+      ActiveSupport::Deprecation.warn('ActionDispatch::ParamsParser is deprecated and will be removed in Rails 5.1. Configure the parameter parsing in ActionDispatch::Request.parameter_parsers.')
+      parsers = parsers.transform_keys { |key| key.respond_to?(:symbol) ? key.symbol : key }
+      ActionDispatch::Request.parameter_parsers = ActionDispatch::Request::DEFAULT_PARSERS.merge(parsers)
+      app
+    end
   end
 end

data/lib/action_dispatch/middleware/public_exceptions.rb

@@ -17,10 +17,10 @@ module ActionDispatch
     end
 
     def call(env)
-      status       = env["PATH_INFO"][1..-1]
       request      = ActionDispatch::Request.new(env)
+      status       = request.path_info[1..-1].to_i
       content_type = request.formats.first
-      body         = { :status => status, :error => Rack::Utils::HTTP_STATUS_CODES.fetch(status.to_i, Rack::Utils::HTTP_STATUS_CODES[500]) }
+      body         = { :status => status, :error => Rack::Utils::HTTP_STATUS_CODES.fetch(status, Rack::Utils::HTTP_STATUS_CODES[500]) }
 
       render(status, content_type, body)
     end