rack 2.0.9.3 → 2.1.4.3

data/lib/rack/directory.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require 'time'
 require 'rack/utils'
 require 'rack/mime'
+require 'rack/files'
 
 module Rack
   # Rack::Directory serves entries below the +root+ given, according to the
@@ -8,7 +11,7 @@ module Rack
   # will be presented in an html based index. If a file is found, the env will
   # be passed to the specified +app+.
   #
-  # If +app+ is not specified, a Rack::File of the same +root+ will be used.
+  # If +app+ is not specified, a Rack::Files of the same +root+ will be used.
 
   class Directory
     DIR_FILE = "<tr><td class='name'><a href='%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>"
@@ -41,9 +44,9 @@ table { width:100%%; }
 
     class DirectoryBody < Struct.new(:root, :path, :files)
       def each
-        show_path = Rack::Utils.escape_html(path.sub(/^#{root}/,''))
-        listings = files.map{|f| DIR_FILE % DIR_FILE_escape(*f) }*"\n"
-        page  = DIR_PAGE % [ show_path, show_path , listings ]
+        show_path = Rack::Utils.escape_html(path.sub(/^#{root}/, ''))
+        listings = files.map{|f| DIR_FILE % DIR_FILE_escape(*f) } * "\n"
+        page = DIR_PAGE % [ show_path, show_path, listings ]
         page.each_line{|l| yield l }
       end
 
@@ -56,9 +59,9 @@ table { width:100%%; }
 
     attr_reader :root, :path
 
-    def initialize(root, app=nil)
+    def initialize(root, app = nil)
       @root = ::File.expand_path(root)
-      @app = app || Rack::File.new(@root)
+      @app = app || Rack::Files.new(@root)
       @head = Rack::Head.new(lambda { |env| get env })
     end
 
@@ -86,9 +89,9 @@ table { width:100%%; }
 
       body = "Bad Request\n"
       size = body.bytesize
-      return [400, {CONTENT_TYPE => "text/plain",
+      return [400, { CONTENT_TYPE => "text/plain",
         CONTENT_LENGTH => size.to_s,
-        "X-Cascade" => "pass"}, [body]]
+        "X-Cascade" => "pass" }, [body]]
     end
 
     def check_forbidden(path_info)
@@ -96,20 +99,20 @@ table { width:100%%; }
 
       body = "Forbidden\n"
       size = body.bytesize
-      return [403, {CONTENT_TYPE => "text/plain",
+      return [403, { CONTENT_TYPE => "text/plain",
         CONTENT_LENGTH => size.to_s,
-        "X-Cascade" => "pass"}, [body]]
+        "X-Cascade" => "pass" }, [body]]
     end
 
     def list_directory(path_info, path, script_name)
-      files = [['../','Parent Directory','','','']]
-      glob = ::File.join(path, '*')
+      files = [['../', 'Parent Directory', '', '', '']]
 
       url_head = (script_name.split('/') + path_info.split('/')).map do |part|
         Rack::Utils.escape_path part
       end
 
-      Dir[glob].sort.each do |node|
+      Dir.entries(path).reject { |e| e.start_with?('.') }.sort.each do |node|
+        node = ::File.join path, node
         stat = stat(node)
         next unless stat
         basename = ::File.basename(node)
@@ -126,7 +129,7 @@ table { width:100%%; }
         files << [ url, basename, size, type, mtime ]
       end
 
-      return [ 200, { CONTENT_TYPE =>'text/html; charset=utf-8'}, DirectoryBody.new(@root, path, files) ]
+      return [ 200, { CONTENT_TYPE => 'text/html; charset=utf-8' }, DirectoryBody.new(@root, path, files) ]
     end
 
     def stat(node)
@@ -154,9 +157,9 @@ table { width:100%%; }
     def entity_not_found(path_info)
       body = "Entity not found: #{path_info}\n"
       size = body.bytesize
-      return [404, {CONTENT_TYPE => "text/plain",
+      return [404, { CONTENT_TYPE => "text/plain",
         CONTENT_LENGTH => size.to_s,
-        "X-Cascade" => "pass"}, [body]]
+        "X-Cascade" => "pass" }, [body]]
     end
 
     # Stolen from Ramaze

data/lib/rack/etag.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rack'
 require 'digest/sha2'
 
@@ -13,7 +15,7 @@ module Rack
   # defaults to nil, while the second defaults to "max-age=0, private, must-revalidate"
   class ETag
     ETAG_STRING = Rack::ETAG
-    DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate".freeze
+    DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate"
 
     def initialize(app, no_cache_control = nil, cache_control = DEFAULT_CACHE_CONTROL)
       @app = app

data/lib/rack/events.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'rack/response'
 require 'rack/body_proxy'
 
 module Rack
   ### This middleware provides hooks to certain places in the request /
-  #response lifecycle.  This is so that middleware that don't need to filter
-  #the response data can safely leave it alone and not have to send messages
-  #down the traditional "rack stack".
+  # response lifecycle.  This is so that middleware that don't need to filter
+  # the response data can safely leave it alone and not have to send messages
+  # down the traditional "rack stack".
   #
   # The events are:
   #

data/lib/rack/file.rb

@@ -1,176 +1,7 @@
-require 'time'
-require 'rack/utils'
-require 'rack/mime'
-require 'rack/request'
-require 'rack/head'
+# frozen_string_literal: true
 
-module Rack
-  # Rack::File serves files below the +root+ directory given, according to the
-  # path info of the Rack request.
-  # e.g. when Rack::File.new("/etc") is used, you can access 'passwd' file
-  # as http://localhost:9292/passwd
-  #
-  # Handlers can detect if bodies are a Rack::File, and use mechanisms
-  # like sendfile on the +path+.
-
-  class File
-    ALLOWED_VERBS = %w[GET HEAD OPTIONS]
-    ALLOW_HEADER = ALLOWED_VERBS.join(', ')
-
-    attr_reader :root
-
-    def initialize(root, headers={}, default_mime = 'text/plain')
-      @root = root
-      @headers = headers
-      @default_mime = default_mime
-      @head = Rack::Head.new(lambda { |env| get env })
-    end
-
-    def call(env)
-      # HEAD requests drop the response body, including 4xx error messages.
-      @head.call env
-    end
-
-    def get(env)
-      request = Rack::Request.new env
-      unless ALLOWED_VERBS.include? request.request_method
-        return fail(405, "Method Not Allowed", {'Allow' => ALLOW_HEADER})
-      end
-
-      path_info = Utils.unescape_path request.path_info
-      return fail(400, "Bad Request") unless Utils.valid_path?(path_info)
-
-      clean_path_info = Utils.clean_path_info(path_info)
-      path = ::File.join(@root, clean_path_info)
-
-      available = begin
-        ::File.file?(path) && ::File.readable?(path)
-      rescue SystemCallError
-        false
-      end
-
-      if available
-        serving(request, path)
-      else
-        fail(404, "File not found: #{path_info}")
-      end
-    end
-
-    def serving(request, path)
-      if request.options?
-        return [200, {'Allow' => ALLOW_HEADER, CONTENT_LENGTH => '0'}, []]
-      end
-      last_modified = ::File.mtime(path).httpdate
-      return [304, {}, []] if request.get_header('HTTP_IF_MODIFIED_SINCE') == last_modified
-
-      headers = { "Last-Modified" => last_modified }
-      mime_type = mime_type path, @default_mime
-      headers[CONTENT_TYPE] = mime_type if mime_type
-
-      # Set custom headers
-      @headers.each { |field, content| headers[field] = content } if @headers
-
-      response = [ 200, headers ]
-
-      size = filesize path
-
-      range = nil
-      ranges = Rack::Utils.get_byte_ranges(request.get_header('HTTP_RANGE'), size)
-      if ranges.nil? || ranges.length > 1
-        # No ranges, or multiple ranges (which we don't support):
-        # TODO: Support multiple byte-ranges
-        response[0] = 200
-        range = 0..size-1
-      elsif ranges.empty?
-        # Unsatisfiable. Return error, and file size:
-        response = fail(416, "Byte range unsatisfiable")
-        response[1]["Content-Range"] = "bytes */#{size}"
-        return response
-      else
-        # Partial content:
-        range = ranges[0]
-        response[0] = 206
-        response[1]["Content-Range"] = "bytes #{range.begin}-#{range.end}/#{size}"
-        size = range.end - range.begin + 1
-      end
+require 'rack/files'
 
-      response[2] = [response_body] unless response_body.nil?
-
-      response[1][CONTENT_LENGTH] = size.to_s
-      response[2] = make_body request, path, range
-      response
-    end
-
-    class Iterator
-      attr_reader :path, :range
-      alias :to_path :path
-
-      def initialize path, range
-        @path  = path
-        @range = range
-      end
-
-      def each
-        ::File.open(path, "rb") do |file|
-          file.seek(range.begin)
-          remaining_len = range.end-range.begin+1
-          while remaining_len > 0
-            part = file.read([8192, remaining_len].min)
-            break unless part
-            remaining_len -= part.length
-
-            yield part
-          end
-        end
-      end
-
-      def close; end
-    end
-
-    private
-
-    def make_body request, path, range
-      if request.head?
-        []
-      else
-        Iterator.new path, range
-      end
-    end
-
-    def fail(status, body, headers = {})
-      body += "\n"
-
-      [
-        status,
-        {
-          CONTENT_TYPE   => "text/plain",
-          CONTENT_LENGTH => body.size.to_s,
-          "X-Cascade" => "pass"
-        }.merge!(headers),
-        [body]
-      ]
-    end
-
-    # The MIME type for the contents of the file located at @path
-    def mime_type path, default_mime
-      Mime.mime_type(::File.extname(path), default_mime)
-    end
-
-    def filesize path
-      # If response_body is present, use its size.
-      return response_body.bytesize if response_body
-
-      #   We check via File::size? whether this file provides size info
-      #   via stat (e.g. /proc files often don't), otherwise we have to
-      #   figure it out by reading the whole file into memory.
-      ::File.size?(path) || ::File.read(path).bytesize
-    end
-
-    # By default, the response body for file requests is nil.
-    # In this case, the response body will be generated later
-    # from the file at @path
-    def response_body
-      nil
-    end
-  end
+module Rack
+  File = Files
 end

data/lib/rack/files.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'rack/utils'
+require 'rack/mime'
+require 'rack/request'
+require 'rack/head'
+
+module Rack
+  # Rack::Files serves files below the +root+ directory given, according to the
+  # path info of the Rack request.
+  # e.g. when Rack::Files.new("/etc") is used, you can access 'passwd' file
+  # as http://localhost:9292/passwd
+  #
+  # Handlers can detect if bodies are a Rack::Files, and use mechanisms
+  # like sendfile on the +path+.
+
+  class Files
+    ALLOWED_VERBS = %w[GET HEAD OPTIONS]
+    ALLOW_HEADER = ALLOWED_VERBS.join(', ')
+
+    attr_reader :root
+
+    def initialize(root, headers = {}, default_mime = 'text/plain')
+      @root = (::File.expand_path(root) if root)
+      @headers = headers
+      @default_mime = default_mime
+      @head = Rack::Head.new(lambda { |env| get env })
+    end
+
+    def call(env)
+      # HEAD requests drop the response body, including 4xx error messages.
+      @head.call env
+    end
+
+    def get(env)
+      request = Rack::Request.new env
+      unless ALLOWED_VERBS.include? request.request_method
+        return fail(405, "Method Not Allowed", { 'Allow' => ALLOW_HEADER })
+      end
+
+      path_info = Utils.unescape_path request.path_info
+      return fail(400, "Bad Request") unless Utils.valid_path?(path_info)
+
+      clean_path_info = Utils.clean_path_info(path_info)
+      path = ::File.join(@root, clean_path_info)
+
+      available = begin
+        ::File.file?(path) && ::File.readable?(path)
+      rescue SystemCallError
+        false
+      end
+
+      if available
+        serving(request, path)
+      else
+        fail(404, "File not found: #{path_info}")
+      end
+    end
+
+    def serving(request, path)
+      if request.options?
+        return [200, { 'Allow' => ALLOW_HEADER, CONTENT_LENGTH => '0' }, []]
+      end
+      last_modified = ::File.mtime(path).httpdate
+      return [304, {}, []] if request.get_header('HTTP_IF_MODIFIED_SINCE') == last_modified
+
+      headers = { "Last-Modified" => last_modified }
+      mime_type = mime_type path, @default_mime
+      headers[CONTENT_TYPE] = mime_type if mime_type
+
+      # Set custom headers
+      @headers.each { |field, content| headers[field] = content } if @headers
+
+      response = [ 200, headers ]
+
+      size = filesize path
+
+      range = nil
+      ranges = Rack::Utils.get_byte_ranges(request.get_header('HTTP_RANGE'), size)
+      if ranges.nil? || ranges.length > 1
+        # No ranges, or multiple ranges (which we don't support):
+        # TODO: Support multiple byte-ranges
+        response[0] = 200
+        range = 0..size - 1
+      elsif ranges.empty?
+        # Unsatisfiable. Return error, and file size:
+        response = fail(416, "Byte range unsatisfiable")
+        response[1]["Content-Range"] = "bytes */#{size}"
+        return response
+      else
+        # Partial content:
+        range = ranges[0]
+        response[0] = 206
+        response[1]["Content-Range"] = "bytes #{range.begin}-#{range.end}/#{size}"
+        size = range.end - range.begin + 1
+      end
+
+      response[2] = [response_body] unless response_body.nil?
+
+      response[1][CONTENT_LENGTH] = size.to_s
+      response[2] = make_body request, path, range
+      response
+    end
+
+    class Iterator
+      attr_reader :path, :range
+      alias :to_path :path
+
+      def initialize path, range
+        @path  = path
+        @range = range
+      end
+
+      def each
+        ::File.open(path, "rb") do |file|
+          file.seek(range.begin)
+          remaining_len = range.end - range.begin + 1
+          while remaining_len > 0
+            part = file.read([8192, remaining_len].min)
+            break unless part
+            remaining_len -= part.length
+
+            yield part
+          end
+        end
+      end
+
+      def close; end
+    end
+
+    private
+
+    def make_body request, path, range
+      if request.head?
+        []
+      else
+        Iterator.new path, range
+      end
+    end
+
+    def fail(status, body, headers = {})
+      body += "\n"
+
+      [
+        status,
+        {
+          CONTENT_TYPE   => "text/plain",
+          CONTENT_LENGTH => body.size.to_s,
+          "X-Cascade" => "pass"
+        }.merge!(headers),
+        [body]
+      ]
+    end
+
+    # The MIME type for the contents of the file located at @path
+    def mime_type path, default_mime
+      Mime.mime_type(::File.extname(path), default_mime)
+    end
+
+    def filesize path
+      # If response_body is present, use its size.
+      return response_body.bytesize if response_body
+
+      #   We check via File::size? whether this file provides size info
+      #   via stat (e.g. /proc files often don't), otherwise we have to
+      #   figure it out by reading the whole file into memory.
+      ::File.size?(path) || ::File.read(path).bytesize
+    end
+
+    # By default, the response body for file requests is nil.
+    # In this case, the response body will be generated later
+    # from the file at @path
+    def response_body
+      nil
+    end
+  end
+end

data/lib/rack/handler/cgi.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'rack/content_length'
 require 'rack/rewindable_input'
 
 module Rack
   module Handler
     class CGI
-      def self.run(app, options=nil)
+      def self.run(app, options = nil)
         $stdin.binmode
         serve app
       end

data/lib/rack/handler/fastcgi.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fcgi'
 require 'socket'
 require 'rack/content_length'
@@ -7,7 +9,7 @@ if defined? FCGI::Stream
   class FCGI::Stream
     alias _rack_read_without_buffer read
 
-    def read(n, buffer=nil)
+    def read(n, buffer = nil)
       buf = _rack_read_without_buffer n
       buffer.replace(buf.to_s)  if buffer
       buf
@@ -18,7 +20,7 @@ end
 module Rack
   module Handler
     class FastCGI
-      def self.run(app, options={})
+      def self.run(app, options = {})
         if options[:File]
           STDIN.reopen(UNIXServer.new(options[:File]))
         elsif options[:Port]

data/lib/rack/handler/lsws.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'lsapi'
 require 'rack/content_length'
 require 'rack/rewindable_input'
@@ -5,7 +7,7 @@ require 'rack/rewindable_input'
 module Rack
   module Handler
     class LSWS
-      def self.run(app, options=nil)
+      def self.run(app, options = nil)
         while LSAPI.accept != nil
           serve app
         end

data/lib/rack/handler/scgi.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'scgi'
 require 'stringio'
 require 'rack/content_length'
@@ -8,12 +10,12 @@ module Rack
     class SCGI < ::SCGI::Processor
       attr_accessor :app
 
-      def self.run(app, options=nil)
+      def self.run(app, options = nil)
         options[:Socket] = UNIXServer.new(options[:File]) if options[:File]
-        new(options.merge(:app=>app,
-                          :host=>options[:Host],
-                          :port=>options[:Port],
-                          :socket=>options[:Socket])).listen
+        new(options.merge(app: app,
+                          host: options[:Host],
+                          port: options[:Port],
+                          socket: options[:Socket])).listen
       end
 
       def self.valid_options
@@ -41,7 +43,8 @@ module Rack
         env[QUERY_STRING] ||= ""
         env[SCRIPT_NAME] = ""
 
-        rack_input = StringIO.new(input_body, encoding: Encoding::BINARY)
+        rack_input = StringIO.new(input_body)
+        rack_input.set_encoding(Encoding::BINARY)
 
         env.update(
           RACK_VERSION      => Rack::VERSION,

data/lib/rack/handler/thin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "thin"
 require "thin/server"
 require "thin/logging"
@@ -8,7 +10,7 @@ require "rack/chunked"
 module Rack
   module Handler
     class Thin
-      def self.run(app, options={})
+      def self.run(app, options = {})
         environment  = ENV['RACK_ENV'] || 'development'
         default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
 

data/lib/rack/handler/webrick.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'webrick'
 require 'stringio'
 require 'rack/content_length'
@@ -22,7 +24,7 @@ end
 module Rack
   module Handler
     class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
-      def self.run(app, options={})
+      def self.run(app, options = {})
         environment  = ENV['RACK_ENV'] || 'development'
         default_host = environment == 'development' ? 'localhost' : nil
 
@@ -79,7 +81,7 @@ module Rack
         env[QUERY_STRING] ||= ""
         unless env[PATH_INFO] == ""
           path, n = req.request_uri.path, env[SCRIPT_NAME].length
-          env[PATH_INFO] = path[n, path.length-n]
+          env[PATH_INFO] = path[n, path.length - n]
         end
         env[REQUEST_PATH] ||= [env[SCRIPT_NAME], env[PATH_INFO]].join
 

data/lib/rack/handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   # *Handlers* connect web servers with Rack.
   #
@@ -17,7 +19,7 @@ module Rack
       end
 
       if klass = @handlers[server]
-        klass.split("::").inject(Object) { |o, x| o.const_get(x) }
+        const_get(klass)
       else
         const_get(server, false)
       end
@@ -43,6 +45,9 @@ module Rack
       raise LoadError, "Couldn't find handler for: #{server_names.join(', ')}."
     end
 
+    SERVER_NAMES = %w(puma thin falcon webrick).freeze
+    private_constant :SERVER_NAMES
+
     def self.default
       # Guess.
       if ENV.include?("PHP_FCGI_CHILDREN")
@@ -52,7 +57,7 @@ module Rack
       elsif ENV.include?("RACK_HANDLER")
         self.get(ENV["RACK_HANDLER"])
       else
-        pick ['puma', 'thin', 'webrick']
+        pick SERVER_NAMES
       end
     end
 

data/lib/rack/head.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rack/body_proxy'
 
 module Rack