rack-contrib 2.0.1 → 2.5.0

data/lib/rack/contrib/lazy_conditional_get.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
 
   ##
@@ -43,6 +45,10 @@ module Rack
   # know for sure that it does not modify the cached content, you can set the
   # `Rack-Lazy-Conditional-Get` on response to `skip`. This will not update the
   # global modification date.
+  #
+  # NOTE: This will not work properly in a multi-threaded environment with
+  # default cache object. A provided cache object should ensure thread-safety
+  # of the `get`/`set`/`[]`/`[]=` methods.
 
   class LazyConditionalGet
 
@@ -68,11 +74,14 @@ module Rack
 
     def call env
       if reading? env and fresh? env
-        return [304, {'Last-Modified' => env['HTTP_IF_MODIFIED_SINCE']}, []]
+        return [304, {'last-modified' => env['HTTP_IF_MODIFIED_SINCE']}, []]
       end
+
       status, headers, body = @app.call env
+      headers = Rack.release < "3" ? Utils::HeaderHash.new(headers) : headers
+
       update_cache unless (reading?(env) or skipping?(headers))
-      headers['Last-Modified'] = cached_value if stampable? headers
+      headers['last-modified'] = cached_value if stampable? headers
       [status, headers, body]
     end
 
@@ -87,11 +96,11 @@ module Rack
     end
 
     def skipping? headers
-      headers['Rack-Lazy-Conditional-Get'] == 'skip'
+      headers['rack-lazy-conditional-get'] == 'skip'
     end
 
     def stampable? headers
-      !headers.has_key?('Last-Modified') and headers['Rack-Lazy-Conditional-Get'] == 'yes'
+      !headers.has_key?('last-modified') and headers['rack-lazy-conditional-get'] == 'yes'
     end
 
     def update_cache

data/lib/rack/contrib/lighttpd_script_name_fix.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   # Lighttpd sets the wrong SCRIPT_NAME and PATH_INFO if you mount your
   # FastCGI app at "/". This middleware fixes this issue.

data/lib/rack/contrib/locale.rb

@@ -1,49 +1,94 @@
+# frozen_string_literal: true
+
 require 'i18n'
 
 module Rack
   class Locale
+    HEADERS_KLASS = Rack.release < "3" ? Utils::HeaderHash : Headers
+    private_constant :HEADERS_KLASS
+
     def initialize(app)
       @app = app
     end
 
     def call(env)
-      old_locale = I18n.locale
-
-      begin
-        locale = accept_locale(env) || I18n.default_locale
-        locale = env['rack.locale'] = I18n.locale = locale.to_s
-        status, headers, body = @app.call(env)
-        headers['Content-Language'] = locale unless headers['Content-Language']
-        [status, headers, body]
-      ensure
-        I18n.locale = old_locale
+      locale_to_restore = I18n.locale
+
+      locale = user_preferred_locale(env["HTTP_ACCEPT_LANGUAGE"])
+      locale ||= I18n.default_locale
+
+      env['rack.locale'] = I18n.locale = locale.to_s
+      status, headers, body = @app.call(env)
+      headers = HEADERS_KLASS.new.merge(headers)
+
+      unless headers['Content-Language']
+        headers['Content-Language'] = locale.to_s
       end
+
+      [status, headers, body]
+    ensure
+      I18n.locale = locale_to_restore
     end
 
     private
 
-    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4
-    def accept_locale(env)
-      accept_langs = env["HTTP_ACCEPT_LANGUAGE"]
-      return if accept_langs.nil?
-
-      languages_and_qvalues = accept_langs.split(",").map { |l|
-        l += ';q=1.0' unless l =~ /;q=\d+(?:\.\d+)?$/
-        l.split(';q=')
-      }
-
-      language_and_qvalue = languages_and_qvalues.sort_by { |(locale, qvalue)|
-        qvalue.to_f
-      }.reverse.detect { |(locale, qvalue)|
-        if I18n.enforce_available_locales
-          locale == '*' || I18n.available_locales.include?(locale.to_sym)
-        else
-          true
+    # Accept-Language header is covered mainly by RFC 7231
+    # https://tools.ietf.org/html/rfc7231
+    #
+    # Related sections:
+    #
+    # * https://tools.ietf.org/html/rfc7231#section-5.3.1
+    # * https://tools.ietf.org/html/rfc7231#section-5.3.5
+    # * https://tools.ietf.org/html/rfc4647#section-3.4
+    #
+    # There is an obsolete RFC 2616 (https://tools.ietf.org/html/rfc2616)
+    #
+    # Edge cases:
+    #
+    # * Value can be a comma separated list with optional whitespaces:
+    #   Accept-Language: da, en-gb;q=0.8, en;q=0.7
+    #
+    # * Quality value can contain optional whitespaces as well:
+    #   Accept-Language: ru-UA, ru; q=0.8, uk; q=0.6, en-US; q=0.4, en; q=0.2
+    #
+    # * Quality prefix 'q=' can be in upper case (Q=)
+    #
+    # * Ignore case when match locale with I18n available locales
+    #
+    def user_preferred_locale(header)
+      return if header.nil?
+
+      locales = header.gsub(/\s+/, '').split(",").map do |language_tag|
+        locale, quality = language_tag.split(/;q=/i)
+        quality = quality ? quality.to_f : 1.0
+        [locale, quality]
+      end.reject do |(locale, quality)|
+        locale == '*' || quality == 0
+      end.sort_by do |(_, quality)|
+        quality
+      end.map(&:first)
+
+      return if locales.empty?
+
+      if I18n.enforce_available_locales
+        locale = locales.reverse.find { |locale| I18n.available_locales.any? { |al| match?(al, locale) } }
+        matched_locale = I18n.available_locales.find { |al| match?(al, locale) } if locale
+        if !locale && !matched_locale
+          matched_locale = locales.reverse.find { |locale| I18n.available_locales.any? { |al| variant_match?(al, locale) } }
+          matched_locale = matched_locale[0,2] if matched_locale
         end
-      }
+        matched_locale
+      else
+        locales.last
+      end
+    end
+
+    def match?(s1, s2)
+      s1.to_s.casecmp(s2.to_s) == 0
+    end
 
-      lang = language_and_qvalue && language_and_qvalue.first
-      lang == '*' ? nil : lang
+    def variant_match?(s1, s2)
+      s1.to_s.casecmp(s2[0,2].to_s) == 0
     end
   end
 end

data/lib/rack/contrib/mailexceptions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'net/smtp'
 require 'mail'
 require 'erb'

data/lib/rack/contrib/nested_params.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rack/utils'
 
 module Rack
@@ -24,7 +26,7 @@ module Rack
         post_body = env[POST_BODY]
         env[FORM_INPUT] = post_body
         env[FORM_HASH] = Rack::Utils.parse_nested_query(post_body.read)
-        post_body.rewind if post_body.respond_to?(:rewind)
+        post_body.rewind
       end
       @app.call(env)
     end

data/lib/rack/contrib/not_found.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   # Rack::NotFound is a default endpoint. Optionally initialize with the
   # path to a custom 404 page, to override the standard response body.
@@ -25,7 +27,7 @@ module Rack
     end
 
     def call(env)
-      [404, {'Content-Type' => @content_type, 'Content-Length' => @length}, [@content]]
+      [404, {'content-type' => @content_type, 'content-length' => @length}, [@content]]
     end
   end
 end

data/lib/rack/contrib/post_body_content_type_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'json'
 rescue LoadError => e
@@ -6,10 +8,51 @@ end
 
 module Rack
 
+  # <b>DEPRECATED:</b> <tt>JSONBodyParser</tt> is a drop-in replacement that is faster and more configurable.
+  #
   # A Rack middleware for parsing POST/PUT body data when Content-Type is
   # not one of the standard supported types, like <tt>application/json</tt>.
   #
-  # TODO: Find a better name.
+  # === How to use the middleware
+  #
+  # Example of simple +config.ru+ file:
+  #
+  #  require 'rack'
+  #  require 'rack/contrib'
+  #
+  #  use ::Rack::PostBodyContentTypeParser
+  #
+  #  app = lambda do |env|
+  #    request = Rack::Request.new(env)
+  #    body = "Hello #{request.params['name']}"
+  #    [200, {'Content-Type' => 'text/plain'}, [body]]
+  #  end
+  #
+  #  run app
+  #
+  # Example with passing block argument:
+  #
+  #   use ::Rack::PostBodyContentTypeParser do |body|
+  #     { 'params' => JSON.parse(body) }
+  #   end
+  #
+  # Example with passing proc argument:
+  #
+  #   parser = ->(body) { { 'params' => JSON.parse(body) } }
+  #   use ::Rack::PostBodyContentTypeParser, &parser
+  #
+  #
+  # === Failed JSON parsing
+  #
+  # Returns "400 Bad request" response if invalid JSON document was sent:
+  #
+  # Raw HTTP response:
+  #
+  #   HTTP/1.1 400 Bad Request
+  #   Content-Type: text/plain
+  #   Content-Length: 28
+  #
+  #   failed to parse body as JSON
   #
   class PostBodyContentTypeParser
 
@@ -24,14 +67,16 @@ module Rack
     #
     APPLICATION_JSON = 'application/json'.freeze
 
-    def initialize(app)
+    def initialize(app, &block)
+      warn "[DEPRECATION] `PostBodyContentTypeParser` is deprecated. Use `JSONBodyParser` as a drop-in replacement."
       @app = app
+      @block = block || Proc.new { |body| JSON.parse(body, :create_additions => false) }
     end
 
     def call(env)
       if Rack::Request.new(env).media_type == APPLICATION_JSON && (body = env[POST_BODY].read).length != 0
-        env[POST_BODY].rewind # somebody might try to read this stream
-        env.update(FORM_HASH => JSON.parse(body, :create_additions => false), FORM_INPUT => env[POST_BODY])
+        env[POST_BODY].rewind if env[POST_BODY].respond_to?(:rewind) # somebody might try to read this stream
+        env.update(FORM_HASH => @block.call(body), FORM_INPUT => env[POST_BODY])
       end
       @app.call(env)
     rescue JSON::ParserError
@@ -39,7 +84,7 @@ module Rack
     end
 
     def bad_request(body = 'Bad Request')
-      [ 400, { 'Content-Type' => 'text/plain', 'Content-Length' => body.size.to_s }, [body] ]
+      [ 400, { 'content-type' => 'text/plain', 'content-length' => body.bytesize.to_s }, [body] ]
     end
   end
 end

data/lib/rack/contrib/printout.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   #prints the environment and request for simple debugging
   class Printout
@@ -6,7 +8,7 @@ module Rack
     end
 
     def call(env)
-      # See http://rack.rubyforge.org/doc/SPEC.html for details
+      # See https://github.com/rack/rack/blob/main/SPEC.rdoc for details
       puts "**********\n Environment\n **************"
       puts env.inspect
       

data/lib/rack/contrib/proctitle.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   # Middleware to update the process title ($0) with information about the
   # current request. Based loosely on:

data/lib/rack/contrib/profiler.rb

@@ -1,10 +1,15 @@
+# frozen_string_literal: true
+
 require 'ruby-prof'
 
 module Rack
   # Set the profile=process_time query parameter to download a
   # calltree profile of the request.
   #
-  # Pass the :printer option to pick a different result format.
+  # Pass the :printer option to pick a different result format.  Note that
+  # some printers (such as CallTreePrinter) have broken the
+  # `AbstractPrinter` API, and thus will not work.  Bug reports to
+  # `ruby-prof`, please, not us.
   #
   # You can cause every request to be run multiple times by passing the
   # `:times` option to the `use Rack::Profiler` call.  You can also run a
@@ -27,10 +32,14 @@ module Rack
     # option defaulting to :call_stack.
     def initialize(app, options = {})
       @app = app
+      @profile = nil
       @printer = parse_printer(options[:printer] || DEFAULT_PRINTER)
       @times = (options[:times] || 1).to_i
+      @maximum_runs = options.fetch(:maximum_runs, 10)
     end
 
+    attr :maximum_runs
+
     def call(env)
       if mode = profiling?(env)
         profile(env, mode)
@@ -41,28 +50,46 @@ module Rack
 
     private
       def profiling?(env)
-        unless ::RubyProf.running?
-          request = Rack::Request.new(env.clone)
-          if mode = request.params.delete('profile')
-            if ::RubyProf.const_defined?(mode.upcase)
-              mode
-            else
-              env['rack.errors'].write "Invalid RubyProf measure_mode: " +
-                "#{mode}. Use one of #{MODES.to_a.join(', ')}"
-              false
-            end
+        return if @profile && @profile.running?
+
+        request = Rack::Request.new(env.clone)
+        if mode = request.params.delete('profile')
+          if ::RubyProf.const_defined?(mode.upcase)
+            mode
+          else
+            env['rack.errors'].write "Invalid RubyProf measure_mode: " +
+              "#{mode}. Use one of #{MODES.to_a.join(', ')}"
+            false
           end
         end
       end
 
+      # How many times to run the request within the profiler.
+      # If the profiler_runs query parameter is set, use that.
+      # Otherwise, use the :times option passed to `#initialize`.
+      # If the profiler_runs query parameter is greater than the
+      # :maximum option passed to `#initialize`, use the :maximum
+      # option.
+      def runs(request)
+        if profiler_runs = request.params['profiler_runs']
+          profiler_runs = profiler_runs.to_i
+          if profiler_runs > @maximum_runs
+            return @maximum_runs
+          else
+            return profiler_runs
+          end
+        else
+          return @times
+        end
+      end
+
       def profile(env, mode)
-        ::RubyProf.measure_mode = ::RubyProf.const_get(mode.upcase)
+        @profile = ::RubyProf::Profile.new(measure_mode: ::RubyProf.const_get(mode.upcase))
 
         GC.enable_stats if GC.respond_to?(:enable_stats)
         request = Rack::Request.new(env.clone)
-        runs = (request.params['profiler_runs'] || @times).to_i
-        result = ::RubyProf.profile do
-          runs.times { @app.call(env) }
+        result = @profile.profile do
+          runs(request).times { @app.call(env) }
         end
         GC.disable_stats if GC.respond_to?(:disable_stats)
 
@@ -77,10 +104,10 @@ module Rack
       end
 
       def headers(printer, env, mode)
-        headers = { 'Content-Type' => CONTENT_TYPES[printer.name] }
+        headers = { 'content-type' => CONTENT_TYPES[printer.name] }
         if printer == ::RubyProf::CallTreePrinter
           filename = ::File.basename(env['PATH_INFO'])
-          headers['Content-Disposition'] =
+          headers['content-disposition'] =
             %(attachment; filename="#{filename}.#{mode}.tree")
         end
         headers

data/lib/rack/contrib/relative_redirect.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rack'
 
 # Rack::RelativeRedirect is a simple middleware that converts relative paths in
@@ -30,15 +32,19 @@ class Rack::RelativeRedirect
   # and use that to make the Location header an absolute url.  If the Location
   # does not start with a slash, make location relative to the path requested.
   def call(env)
-    res = @app.call(env)
-    if [301,302,303, 307,308].include?(res[0]) and loc = res[1]['Location'] and !%r{\Ahttps?://}o.match(loc)
-      absolute = @absolute_proc.call(env, res)
-      res[1]['Location'] = if %r{\A/}.match(loc)
+    status, headers, body = @app.call(env)
+    headers_klass = Rack.release < "3" ? Rack::Utils::HeaderHash : Rack::Headers
+    headers = headers_klass.new.merge(headers)
+
+    if [301,302,303, 307,308].include?(status) and loc = headers['Location'] and !%r{\Ahttps?://}o.match(loc)
+      absolute = @absolute_proc.call(env, [status, headers, body])
+      headers['Location'] = if %r{\A/}.match(loc)
         "#{absolute}#{loc}"
       else
         "#{absolute}#{File.dirname(Rack::Utils.unescape(env['PATH_INFO']))}/#{loc}"
       end
     end
-    res
+
+    [status, headers, body]
   end
 end

data/lib/rack/contrib/response_cache.rb

@@ -1,11 +1,16 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'rack'
 
 # Rack::ResponseCache is a Rack middleware that caches responses for successful
 # GET requests with no query string to disk or any ruby object that has an
-# []= method (so it works with memcached).  When caching to disk, it works similar to
-# Rails' page caching, allowing you to cache dynamic pages to static files that can
-# be served directly by a front end webserver.
+# []= method (so it works with memcached). As with Rails' page caching, this
+# middleware only writes to the cache -- it never reads. The logic of whether a
+# cached response should be served is left either to your web server, via
+# something like the <tt>try_files</tt> directive in nginx, or to your
+# cache-reading middleware of choice, mounted before Rack::ResponseCache in the
+# stack.
 class Rack::ResponseCache
   # The default proc used if a block is not provided to .new
   # It unescapes the PATH_INFO of the environment, and makes sure that it doesn't
@@ -15,7 +20,10 @@ class Rack::ResponseCache
   # of the path to index.html.
   DEFAULT_PATH_PROC = proc do |env, res|
     path = Rack::Utils.unescape(env['PATH_INFO'])
-    if !path.include?('..') and match = /text\/((?:x|ht)ml|css)/o.match(res[1]['Content-Type'])
+    headers = res[1]
+    content_type = headers['Content-Type']
+
+    if !path.include?('..') and match = /text\/((?:x|ht)ml|css)/o.match(content_type)
       type = match[1]
       path = "#{path}.#{type}" unless /\.#{type}\z/.match(path)
       path = File.join(File.dirname(path), 'index.html') if type == 'html' and File.basename(path) == '.html'
@@ -44,16 +52,20 @@ class Rack::ResponseCache
   # If the cache is a string, create any necessary middle directories, and cache the file in the appropriate
   # subdirectory of cache.  Otherwise, cache the body of the response as the value with the path as the key.
   def call(env)
-    res = @app.call(env)
-    if env['REQUEST_METHOD'] == 'GET' and env['QUERY_STRING'] == '' and res[0] == 200 and path = @path_proc.call(env, res)
+    status, headers, body = @app.call(env)
+    headers_klass = Rack.release < "3" ? Rack::Utils::HeaderHash : Rack::Headers
+    headers = headers_klass.new.merge(headers)
+
+    if env['REQUEST_METHOD'] == 'GET' and env['QUERY_STRING'] == '' and status == 200 and path = @path_proc.call(env, [status, headers, body])
       if @cache.is_a?(String)
         path = File.join(@cache, path) if @cache
         FileUtils.mkdir_p(File.dirname(path))
-        File.open(path, 'wb'){|f| res[2].each{|c| f.write(c)}}
+        File.open(path, 'wb'){|f| body.each{|c| f.write(c)}}
       else
-        @cache[path] = res[2]
+        @cache[path] = body
       end
     end
-    res
+
+    [status, headers, body]
   end
 end

data/lib/rack/contrib/response_headers.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module Rack
   # Allows you to tap into the response headers. Yields a Rack::Utils::HeaderHash
-  # of current response headers to the block. Example:
+  # (Rack 2) or a Rack::Headers (Rack 3) of current response headers to the block.
+  # Example:
   #
   #   use Rack::ResponseHeaders do |headers|
   #     headers['X-Foo'] = 'bar'
@@ -8,6 +11,9 @@ module Rack
   #   end
   #
   class ResponseHeaders
+    HEADERS_KLASS = Rack.release < "3" ? Utils::HeaderHash : Headers
+    private_constant :HEADERS_KLASS
+
     def initialize(app, &block)
       @app = app
       @block = block
@@ -15,7 +21,7 @@ module Rack
 
     def call(env)
       response = @app.call(env)
-      headers = Utils::HeaderHash.new(response[1])
+      headers = HEADERS_KLASS.new.merge(response[1])
       @block.call(headers)
       response[1] = headers
       response

data/lib/rack/contrib/route_exceptions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class RouteExceptions
     ROUTES = [

data/lib/rack/contrib/runtime.rb

@@ -1,31 +1,4 @@
+# frozen_string_literal: true
 
-module Rack
-  # Sets an "X-Runtime" response header, indicating the response
-  # time of the request, in seconds
-  #
-  # You can put it right before the application to see the processing
-  # time, or before all the other middlewares to include time for them,
-  # too.
-  class Runtime
-    def initialize(app, name = nil)
-      @app = app
-      @header_name = "X-Runtime"
-      @header_name << "-#{name}" if name
-    end
-
-    def call(env)
-      start_time = Time.now
-      status, headers, body = @app.call(env)
-      request_time = Time.now - start_time
-
-      if !headers.has_key?(@header_name)
-        headers[@header_name] = "%0.6f" % request_time
-      end
-
-      [status, headers, body]
-    end
-  end
-end
-
-
-
+require 'rack'
+require 'rack/runtime'

data/lib/rack/contrib/signals.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   # Installs signal handlers that are safely processed after a request
   #
@@ -24,6 +26,10 @@ module Rack
         @body.each(&block)
         @callback.call
       end
+
+      def close
+        @body.close if @body.respond_to?(:close)
+      end
     end
 
     def initialize(app, &block)

data/lib/rack/contrib/simple_endpoint.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   # Create simple endpoints with routing rules, similar to Sinatra actions.
   #
@@ -78,4 +80,4 @@ module Rack
         @verbs.empty? || @verbs.include?(method)
       end
   end
-end
+end