actionpack 5.0.7.2 → 5.1.0.beta1

data/lib/action_dispatch/middleware/debug_locks.rb

@@ -21,7 +21,7 @@ module ActionDispatch
   # This middleware exposes operational details of the server, with no access
   # control. It should only be enabled when in use, and removed thereafter.
   class DebugLocks
-    def initialize(app, path = '/rails/locks')
+    def initialize(app, path = "/rails/locks")
       @app = app
       @path = path
     end
@@ -30,7 +30,7 @@ module ActionDispatch
       req = ActionDispatch::Request.new env
 
       if req.get?
-        path = req.path_info.chomp('/'.freeze)
+        path = req.path_info.chomp("/".freeze)
         if path == @path
           return render_details(req)
         end
@@ -61,16 +61,16 @@ module ActionDispatch
 
         str = threads.map do |thread, info|
           if info[:exclusive]
-            lock_state = 'Exclusive'
+            lock_state = "Exclusive"
           elsif info[:sharing] > 0
-            lock_state = 'Sharing'
+            lock_state = "Sharing"
             lock_state << " x#{info[:sharing]}" if info[:sharing] > 1
           else
-            lock_state = 'No lock'
+            lock_state = "No lock"
           end
 
           if info[:waiting]
-            lock_state << ' (yielded share)'
+            lock_state << " (yielded share)"
           end
 
           msg = "Thread #{info[:index]} [0x#{thread.__id__.to_s(16)} #{thread.status || 'dead'}]  #{lock_state}\n"
@@ -86,11 +86,11 @@ module ActionDispatch
             end
 
             blockers = threads.values.select { |binfo| blocked_by?(info, binfo, threads.values) }
-            msg << "  blocked by: #{blockers.map {|i| i[:index] }.join(', ')}\n" if blockers.any?
+            msg << "  blocked by: #{blockers.map { |i| i[:index] }.join(', ')}\n" if blockers.any?
           end
 
           blockees = threads.values.select { |binfo| blocked_by?(binfo, info, threads.values) }
-          msg << "  blocking: #{blockees.map {|i| i[:index] }.join(', ')}\n" if blockees.any?
+          msg << "  blocking: #{blockees.map { |i| i[:index] }.join(', ')}\n" if blockees.any?
 
           msg << "\n#{info[:backtrace].join("\n")}\n" if info[:backtrace]
         end.join("\n\n---\n\n\n")

data/lib/action_dispatch/middleware/exception_wrapper.rb

@@ -1,33 +1,33 @@
-require 'active_support/core_ext/module/attribute_accessors'
-require 'rack/utils'
+require "active_support/core_ext/module/attribute_accessors"
+require "rack/utils"
 
 module ActionDispatch
   class ExceptionWrapper
     cattr_accessor :rescue_responses
     @@rescue_responses = Hash.new(:internal_server_error)
     @@rescue_responses.merge!(
-      'ActionController::RoutingError'                => :not_found,
-      'AbstractController::ActionNotFound'            => :not_found,
-      'ActionController::MethodNotAllowed'            => :method_not_allowed,
-      'ActionController::UnknownHttpMethod'           => :method_not_allowed,
-      'ActionController::NotImplemented'              => :not_implemented,
-      'ActionController::UnknownFormat'               => :not_acceptable,
-      'ActionController::InvalidAuthenticityToken'    => :unprocessable_entity,
-      'ActionController::InvalidCrossOriginRequest'   => :unprocessable_entity,
-      'ActionDispatch::ParamsParser::ParseError'      => :bad_request,
-      'ActionController::BadRequest'                  => :bad_request,
-      'ActionController::ParameterMissing'            => :bad_request,
-      'Rack::QueryParser::ParameterTypeError'         => :bad_request,
-      'Rack::QueryParser::InvalidParameterError'      => :bad_request
+      "ActionController::RoutingError"               => :not_found,
+      "AbstractController::ActionNotFound"           => :not_found,
+      "ActionController::MethodNotAllowed"           => :method_not_allowed,
+      "ActionController::UnknownHttpMethod"          => :method_not_allowed,
+      "ActionController::NotImplemented"             => :not_implemented,
+      "ActionController::UnknownFormat"              => :not_acceptable,
+      "ActionController::InvalidAuthenticityToken"   => :unprocessable_entity,
+      "ActionController::InvalidCrossOriginRequest"  => :unprocessable_entity,
+      "ActionDispatch::Http::Parameters::ParseError" => :bad_request,
+      "ActionController::BadRequest"                 => :bad_request,
+      "ActionController::ParameterMissing"           => :bad_request,
+      "Rack::QueryParser::ParameterTypeError"        => :bad_request,
+      "Rack::QueryParser::InvalidParameterError"     => :bad_request
     )
 
     cattr_accessor :rescue_templates
-    @@rescue_templates = Hash.new('diagnostics')
+    @@rescue_templates = Hash.new("diagnostics")
     @@rescue_templates.merge!(
-      'ActionView::MissingTemplate'         => 'missing_template',
-      'ActionController::RoutingError'      => 'routing_error',
-      'AbstractController::ActionNotFound'  => 'unknown_action',
-      'ActionView::Template::Error'         => 'template_error'
+      "ActionView::MissingTemplate"         => "missing_template",
+      "ActionController::RoutingError"      => "routing_error",
+      "AbstractController::ActionNotFound"  => "unknown_action",
+      "ActionView::Template::Error"         => "template_error"
     )
 
     attr_reader :backtrace_cleaner, :exception, :line_number, :file
@@ -100,49 +100,49 @@ module ActionDispatch
 
     private
 
-    def backtrace
-      Array(@exception.backtrace)
-    end
+      def backtrace
+        Array(@exception.backtrace)
+      end
 
-    def original_exception(exception)
-      if @@rescue_responses.has_key?(exception.cause.class.name)
-        exception.cause
-      else
-        exception
+      def original_exception(exception)
+        if @@rescue_responses.has_key?(exception.cause.class.name)
+          exception.cause
+        else
+          exception
+        end
       end
-    end
 
-    def clean_backtrace(*args)
-      if backtrace_cleaner
-        backtrace_cleaner.clean(backtrace, *args)
-      else
-        backtrace
+      def clean_backtrace(*args)
+        if backtrace_cleaner
+          backtrace_cleaner.clean(backtrace, *args)
+        else
+          backtrace
+        end
       end
-    end
 
-    def source_fragment(path, line)
-      return unless Rails.respond_to?(:root) && Rails.root
-      full_path = Rails.root.join(path)
-      if File.exist?(full_path)
-        File.open(full_path, "r") do |file|
-          start = [line - 3, 0].max
-          lines = file.each_line.drop(start).take(6)
-          Hash[*(start+1..(lines.count+start)).zip(lines).flatten]
+      def source_fragment(path, line)
+        return unless Rails.respond_to?(:root) && Rails.root
+        full_path = Rails.root.join(path)
+        if File.exist?(full_path)
+          File.open(full_path, "r") do |file|
+            start = [line - 3, 0].max
+            lines = file.each_line.drop(start).take(6)
+            Hash[*(start + 1..(lines.count + start)).zip(lines).flatten]
+          end
         end
       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 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")
-      ).flatten!
-    end
+      def expand_backtrace
+        @exception.backtrace.unshift(
+          @exception.to_s.split("\n")
+        ).flatten!
+      end
   end
 end

data/lib/action_dispatch/middleware/executor.rb

@@ -1,4 +1,4 @@
-require 'rack/body_proxy'
+require "rack/body_proxy"
 
 module ActionDispatch
   class Executor

data/lib/action_dispatch/middleware/flash.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/hash/keys'
+require "active_support/core_ext/hash/keys"
 
 module ActionDispatch
   # The flash provides a way to pass temporary primitive-types (String, Array, Hash) between actions. Anything you place in the flash will be exposed
@@ -36,7 +36,7 @@ module ActionDispatch
   #
   # See docs on the FlashHash class for more details about the flash.
   class Flash
-    KEY = 'action_dispatch.request.flash_hash'.freeze
+    KEY = "action_dispatch.request.flash_hash".freeze
 
     module RequestMethods
       # Access the contents of the flash. Use <tt>flash["notice"]</tt> to
@@ -60,14 +60,14 @@ module ActionDispatch
         session    = self.session || {}
         flash_hash = self.flash_hash
 
-        if flash_hash && (flash_hash.present? || session.key?('flash'))
+        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')
+            session.key?("flash") && session["flash"].nil?
+          session.delete("flash")
         end
       end
 
@@ -118,8 +118,8 @@ module ActionDispatch
           end
           new(flashes, flashes.keys)
         when Hash # Rails 4.0
-          flashes = value['flashes']
-          if discard = value['discard']
+          flashes = value["flashes"]
+          if discard = value["discard"]
             flashes.except!(*discard)
           end
           new(flashes, flashes.keys)
@@ -129,11 +129,11 @@ module ActionDispatch
       end
 
       # Builds a hash containing the flashes to keep for the next request.
-      # If there are none to keep, returns nil.
+      # If there are none to keep, returns +nil+.
       def to_session_value #:nodoc:
         flashes_to_keep = @flashes.except(*@discard)
         return nil if flashes_to_keep.empty?
-        { 'discard' => [], 'flashes' => flashes_to_keep }
+        { "discard" => [], "flashes" => flashes_to_keep }
       end
 
       def initialize(flashes = {}, discard = []) #:nodoc:
@@ -277,15 +277,16 @@ module ActionDispatch
       end
 
       protected
-      def now_is_loaded?
-        @now
-      end
+        def now_is_loaded?
+          @now
+        end
 
-      def stringify_array(array)
-        array.map do |item|
-          item.kind_of?(Symbol) ? item.to_s : item
+      private
+        def stringify_array(array) # :doc:
+          array.map do |item|
+            item.kind_of?(Symbol) ? item.to_s : item
+          end
         end
-      end
     end
 
     def self.new(app) app; end

data/lib/action_dispatch/middleware/public_exceptions.rb

@@ -20,36 +20,36 @@ module ActionDispatch
       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, 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
 
     private
 
-    def render(status, content_type, body)
-      format = "to_#{content_type.to_sym}" if content_type
-      if format && body.respond_to?(format)
-        render_format(status, content_type, body.public_send(format))
-      else
-        render_html(status)
+      def render(status, content_type, body)
+        format = "to_#{content_type.to_sym}" if content_type
+        if format && body.respond_to?(format)
+          render_format(status, content_type, body.public_send(format))
+        else
+          render_html(status)
+        end
       end
-    end
 
-    def render_format(status, content_type, body)
-      [status, {'Content-Type' => "#{content_type}; charset=#{ActionDispatch::Response.default_charset}",
-                'Content-Length' => body.bytesize.to_s}, [body]]
-    end
+      def render_format(status, content_type, body)
+        [status, { "Content-Type" => "#{content_type}; charset=#{ActionDispatch::Response.default_charset}",
+                  "Content-Length" => body.bytesize.to_s }, [body]]
+      end
 
-    def render_html(status)
-      path = "#{public_path}/#{status}.#{I18n.locale}.html"
-      path = "#{public_path}/#{status}.html" unless (found = File.exist?(path))
+      def render_html(status)
+        path = "#{public_path}/#{status}.#{I18n.locale}.html"
+        path = "#{public_path}/#{status}.html" unless (found = File.exist?(path))
 
-      if found || File.exist?(path)
-        render_format(status, 'text/html', File.read(path))
-      else
-        [404, { "X-Cascade" => "pass" }, []]
+        if found || File.exist?(path)
+          render_format(status, "text/html", File.read(path))
+        else
+          [404, { "X-Cascade" => "pass" }, []]
+        end
       end
-    end
   end
 end

data/lib/action_dispatch/middleware/reloader.rb

@@ -1,54 +1,10 @@
 module ActionDispatch
-  # ActionDispatch::Reloader provides prepare and cleanup callbacks,
-  # intended to assist with code reloading during development.
-  #
-  # Prepare callbacks are run before each request, and cleanup callbacks
-  # after each request. In this respect they are analogs of ActionDispatch::Callback's
-  # before and after callbacks. However, cleanup callbacks are not called until the
-  # request is fully complete -- that is, after #close has been called on
-  # the response body. This is important for streaming responses such as the
-  # following:
-  #
-  #     self.response_body = -> (response, output) do
-  #       # code here which refers to application models
-  #     end
-  #
-  # Cleanup callbacks will not be called until after the response_body lambda
-  # is evaluated, ensuring that it can refer to application models and other
-  # classes before they are unloaded.
+  # ActionDispatch::Reloader wraps the request with callbacks provided by ActiveSupport::Reloader
+  # callbacks, intended to assist with code reloading during development.
   #
   # By default, ActionDispatch::Reloader is included in the middleware stack
   # only in the development environment; specifically, when +config.cache_classes+
-  # is false. Callbacks may be registered even when it is not included in the
-  # middleware stack, but are executed only when <tt>ActionDispatch::Reloader.prepare!</tt>
-  # or <tt>ActionDispatch::Reloader.cleanup!</tt> are called manually.
-  #
+  # is false.
   class Reloader < Executor
-    def self.to_prepare(*args, &block)
-      ActiveSupport::Reloader.to_prepare(*args, &block)
-    end
-
-    def self.to_cleanup(*args, &block)
-      ActiveSupport::Reloader.to_complete(*args, &block)
-    end
-
-    def self.prepare!
-      default_reloader.prepare!
-    end
-
-    def self.cleanup!
-      default_reloader.reload!
-    end
-
-    class << self
-      attr_accessor :default_reloader # :nodoc:
-
-      deprecate to_prepare: 'use ActiveSupport::Reloader.to_prepare instead',
-        to_cleanup: 'use ActiveSupport::Reloader.to_complete instead',
-        prepare!: 'use Rails.application.reloader.prepare! instead',
-        cleanup!: 'use Rails.application.reloader.reload! instead of cleanup + prepare'
-    end
-
-    self.default_reloader = ActiveSupport::Reloader
   end
 end

data/lib/action_dispatch/middleware/remote_ip.rb

@@ -1,4 +1,4 @@
-require 'ipaddr'
+require "ipaddr"
 
 module ActionDispatch
   # This middleware calculates the IP address of the remote client that is
@@ -131,8 +131,8 @@ module ActionDispatch
         should_check_ip = @check_ip && client_ips.last && forwarded_ips.last
         if should_check_ip && !forwarded_ips.include?(client_ips.last)
           # We don't know which came from the proxy, and which from the user
-          raise IpSpoofAttackError, "IP spoofing attack?! " +
-            "HTTP_CLIENT_IP=#{@req.client_ip.inspect} " +
+          raise IpSpoofAttackError, "IP spoofing attack?! " \
+            "HTTP_CLIENT_IP=#{@req.client_ip.inspect} " \
             "HTTP_X_FORWARDED_FOR=#{@req.x_forwarded_for.inspect}"
         end
 
@@ -153,9 +153,9 @@ module ActionDispatch
         @ip ||= calculate_ip
       end
 
-    protected
+    private
 
-      def ips_from(header)
+      def ips_from(header) # :doc:
         return [] unless header
         # Split the comma-separated list into an array of strings
         ips = header.strip.split(/[,\s]+/)
@@ -171,13 +171,11 @@ module ActionDispatch
         end
       end
 
-      def filter_proxies(ips)
+      def filter_proxies(ips) # :doc:
         ips.reject do |ip|
           @proxies.any? { |proxy| proxy === ip }
         end
       end
-
     end
-
   end
 end

data/lib/action_dispatch/middleware/request_id.rb

@@ -1,9 +1,10 @@
-require 'securerandom'
-require 'active_support/core_ext/string/access'
+require "securerandom"
+require "active_support/core_ext/string/access"
 
 module ActionDispatch
-  # Makes a unique request id available to the action_dispatch.request_id env variable (which is then accessible through
-  # ActionDispatch::Request#uuid or the alias ActionDispatch::Request#request_id) and sends the same id to the client via the X-Request-Id header.
+  # Makes a unique request id available to the +action_dispatch.request_id+ env variable (which is then accessible
+  # through <tt>ActionDispatch::Request#request_id</tt> or the alias <tt>ActionDispatch::Request#uuid</tt>) and sends
+  # the same id to the client via the X-Request-Id header.
   #
   # The unique request id is either based on the X-Request-Id header in the request, which would typically be generated
   # by a firewall, load balancer, or the web server, or, if this header is not available, a random uuid. If the
@@ -12,7 +13,7 @@ module ActionDispatch
   # The unique request id can be used to trace a request end-to-end and would typically end up being part of log files
   # from multiple pieces of the stack.
   class RequestId
-    X_REQUEST_ID = "X-Request-Id".freeze # :nodoc:
+    X_REQUEST_ID = "X-Request-Id".freeze #:nodoc:
 
     def initialize(app)
       @app = app