rack 1.1.6 → 1.6.9

data/lib/rack/session/memcache.rb

@@ -21,6 +21,7 @@ module Rack
 
     class Memcache < Abstract::ID
       attr_reader :mutex, :pool
+
       DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge \
         :namespace => 'rack:session',
         :memcache_server => 'localhost:11211'
@@ -30,9 +31,9 @@ module Rack
 
         @mutex = Mutex.new
         mserv = @default_options[:memcache_server]
-        mopts = @default_options.
-          reject{|k,v| MemCache::DEFAULT_OPTIONS.include? k }
-        @pool = MemCache.new mserv, mopts
+        mopts = @default_options.reject{|k,v| !MemCache::DEFAULT_OPTIONS.include? k }
+
+        @pool = options[:cache] || MemCache.new(mserv, mopts)
         unless @pool.active? and @pool.servers.any?{|c| c.alive? }
           raise 'No memcache servers'
         end
@@ -45,75 +46,48 @@ module Rack
         end
       end
 
-      def get_session(env, session_id)
-        @mutex.lock if env['rack.multithread']
-        unless session_id and session = @pool.get(session_id)
-          session_id, session = generate_sid, {}
-          unless /^STORED/ =~ @pool.add(session_id, session)
-            raise "Session collision on '#{session_id.inspect}'"
+      def get_session(env, sid)
+        with_lock(env) do
+          unless sid and session = @pool.get(sid)
+            sid, session = generate_sid, {}
+            unless /^STORED/ =~ @pool.add(sid, session)
+              raise "Session collision on '#{sid.inspect}'"
+            end
           end
+          [sid, session]
         end
-        session.instance_variable_set '@old', @pool.get(session_id, true)
-        return [session_id, session]
-      rescue MemCache::MemCacheError, Errno::ECONNREFUSED
-        # MemCache server cannot be contacted
-        warn "#{self} is unable to find memcached server."
-        warn $!.inspect
-        return [ nil, {} ]
-      ensure
-        @mutex.unlock if @mutex.locked?
       end
 
       def set_session(env, session_id, new_session, options)
         expiry = options[:expire_after]
         expiry = expiry.nil? ? 0 : expiry + 1
 
-        @mutex.lock if env['rack.multithread']
-        if options[:renew] or options[:drop]
-          @pool.delete session_id
-          return false if options[:drop]
-          session_id = generate_sid
-          @pool.add session_id, {} # so we don't worry about cache miss on #set
+        with_lock(env) do
+          @pool.set session_id, new_session, expiry
+          session_id
         end
+      end
 
-        session = @pool.get(session_id) || {}
-        old_session = new_session.instance_variable_get '@old'
-        old_session = old_session ? Marshal.load(old_session) : {}
-
-        unless Hash === old_session and Hash === new_session
-          env['rack.errors'].
-            puts 'Bad old_session or new_session sessions provided.'
-        else # merge sessions
-          # alterations are either update or delete, making as few changes as
-          # possible to prevent possible issues.
-
-          # removed keys
-          delete = old_session.keys - new_session.keys
-          if $VERBOSE and not delete.empty?
-            env['rack.errors'].
-              puts "//@#{session_id}: delete #{delete*','}"
-          end
-          delete.each{|k| session.delete k }
-
-          # added or altered keys
-          update = new_session.keys.
-            select{|k| new_session[k] != old_session[k] }
-          if $VERBOSE and not update.empty?
-            env['rack.errors'].puts "//@#{session_id}: update #{update*','}"
-          end
-          update.each{|k| session[k] = new_session[k] }
+      def destroy_session(env, session_id, options)
+        with_lock(env) do
+          @pool.delete(session_id)
+          generate_sid unless options[:drop]
         end
+      end
 
-        @pool.set session_id, session, expiry
-        return session_id
+      def with_lock(env)
+        @mutex.lock if env['rack.multithread']
+        yield
       rescue MemCache::MemCacheError, Errno::ECONNREFUSED
-        # MemCache server cannot be contacted
-        warn "#{self} is unable to find memcached server."
-        warn $!.inspect
-        return false
+        if $VERBOSE
+          warn "#{self} is unable to find memcached server."
+          warn $!.inspect
+        end
+        raise
       ensure
         @mutex.unlock if @mutex.locked?
       end
+
     end
   end
 end

data/lib/rack/session/pool.rb

@@ -42,58 +42,34 @@ module Rack
       end
 
       def get_session(env, sid)
-        session = @pool[sid] if sid
-        @mutex.lock if env['rack.multithread']
-        unless sid and session
-          env['rack.errors'].puts("Session '#{sid.inspect}' not found, initializing...") if $VERBOSE and not sid.nil?
-          session = {}
-          sid = generate_sid
-          @pool.store sid, session
+        with_lock(env) do
+          unless sid and session = @pool[sid]
+            sid, session = generate_sid, {}
+            @pool.store sid, session
+          end
+          [sid, session]
         end
-        session.instance_variable_set('@old', {}.merge(session))
-        return [sid, session]
-      ensure
-        @mutex.unlock if env['rack.multithread']
       end
 
       def set_session(env, session_id, new_session, options)
-        @mutex.lock if env['rack.multithread']
-        session = @pool[session_id]
-        if options[:renew] or options[:drop]
-          @pool.delete session_id
-          return false if options[:drop]
-          session_id = generate_sid
-          @pool.store session_id, 0
+        with_lock(env) do
+          @pool.store session_id, new_session
+          session_id
         end
-        old_session = new_session.instance_variable_get('@old') || {}
-        session = merge_sessions session_id, old_session, new_session, session
-        @pool.store session_id, session
-        return session_id
-      rescue
-        warn "#{new_session.inspect} has been lost."
-        warn $!.inspect
-      ensure
-        @mutex.unlock if env['rack.multithread']
       end
 
-      private
-
-      def merge_sessions sid, old, new, cur=nil
-        cur ||= {}
-        unless Hash === old and Hash === new
-          warn 'Bad old or new sessions provided.'
-          return cur
+      def destroy_session(env, session_id, options)
+        with_lock(env) do
+          @pool.delete(session_id)
+          generate_sid unless options[:drop]
         end
+      end
 
-        delete = old.keys - new.keys
-        warn "//@#{sid}: dropping #{delete*','}" if $DEBUG and not delete.empty?
-        delete.each{|k| cur.delete k }
-
-        update = new.keys.select{|k| new[k] != old[k] }
-        warn "//@#{sid}: updating #{update*','}" if $DEBUG and not update.empty?
-        update.each{|k| cur[k] = new[k] }
-
-        cur
+      def with_lock(env)
+        @mutex.lock if env['rack.multithread']
+        yield
+      ensure
+        @mutex.unlock if @mutex.locked?
       end
     end
   end

data/lib/rack/showexceptions.rb

@@ -23,18 +23,54 @@ module Rack
     def call(env)
       @app.call(env)
     rescue StandardError, LoadError, SyntaxError => e
-      backtrace = pretty(env, e)
-      [500,
-       {"Content-Type" => "text/html",
-        "Content-Length" => backtrace.join.size.to_s},
-       backtrace]
+      exception_string = dump_exception(e)
+
+      env["rack.errors"].puts(exception_string)
+      env["rack.errors"].flush
+
+      if accepts_html?(env)
+        content_type = "text/html"
+        body = pretty(env, e)
+      else
+        content_type = "text/plain"
+        body = exception_string
+      end
+
+      [
+        500,
+        {
+          CONTENT_TYPE => content_type,
+          CONTENT_LENGTH => Rack::Utils.bytesize(body).to_s,
+        },
+        [body],
+      ]
+    end
+
+    def prefers_plaintext?(env)
+      !accepts_html(env)
+    end
+
+    def accepts_html?(env)
+      Rack::Utils.best_q_match(env["HTTP_ACCEPT"], %w[text/html])
+    end
+    private :accepts_html?
+
+    def dump_exception(exception)
+      string = "#{exception.class}: #{exception.message}\n"
+      string << exception.backtrace.map { |l| "\t#{l}" }.join("\n")
+      string
     end
 
     def pretty(env, exception)
       req = Rack::Request.new(env)
-      path = (req.script_name + req.path_info).squeeze("/")
 
-      frames = exception.backtrace.map { |line|
+      # This double assignment is to prevent an "unused variable" warning on
+      # Ruby 1.9.3.  Yes, it is dumb, but I don't like Ruby yelling at me.
+      path = path = (req.script_name + req.path_info).squeeze("/")
+
+      # This double assignment is to prevent an "unused variable" warning on
+      # Ruby 1.9.3.  Yes, it is dumb, but I don't like Ruby yelling at me.
+      frames = frames = exception.backtrace.map { |line|
         frame = OpenStruct.new
         if line =~ /(.*?):(\d+)(:in `(.*)')?/
           frame.filename = $1
@@ -58,11 +94,7 @@ module Rack
         end
       }.compact
 
-      env["rack.errors"].puts "#{exception.class}: #{exception.message}"
-      env["rack.errors"].puts exception.backtrace.map { |l| "\t" + l }
-      env["rack.errors"].flush
-
-      [@template.result(binding)]
+      @template.result(binding)
     end
 
     def h(obj)                  # :nodoc:
@@ -195,7 +227,13 @@ TEMPLATE = <<'HTML'
   <h2><%=h exception.message %></h2>
   <table><tr>
     <th>Ruby</th>
-    <td><code><%=h frames.first.filename %></code>: in <code><%=h frames.first.function %></code>, line <%=h frames.first.lineno %></td>
+    <td>
+<% if first = frames.first %>
+      <code><%=h first.filename %></code>: in <code><%=h first.function %></code>, line <%=h frames.first.lineno %>
+<% else %>
+      unknown location
+<% end %>
+    </td>
   </tr><tr>
     <th>Web</th>
     <td><code><%=h req.request_method %> <%=h(req.host + path)%></code></td>
@@ -248,7 +286,7 @@ TEMPLATE = <<'HTML'
   <h2>Request information</h2>
 
   <h3 id="get-info">GET</h3>
-  <% unless req.GET.empty? %>
+  <% if req.GET and not req.GET.empty? %>
     <table class="req">
       <thead>
         <tr>
@@ -270,7 +308,7 @@ TEMPLATE = <<'HTML'
   <% end %>
 
   <h3 id="post-info">POST</h3>
-  <% unless req.POST.empty? %>
+  <% if req.POST and not req.POST.empty? %>
     <table class="req">
       <thead>
         <tr>

data/lib/rack/showstatus.rb

@@ -3,8 +3,8 @@ require 'rack/request'
 require 'rack/utils'
 
 module Rack
-  # Rack::ShowStatus catches all empty responses the app it wraps and
-  # replaces them with a site explaining the error.
+  # Rack::ShowStatus catches all empty responses and replaces them
+  # with a site explaining the error.
   #
   # Additional details can be put into <tt>rack.showstatus.detail</tt>
   # and will be shown as HTML.  If such details exist, the error page
@@ -19,16 +19,23 @@ module Rack
     def call(env)
       status, headers, body = @app.call(env)
       headers = Utils::HeaderHash.new(headers)
-      empty = headers['Content-Length'].to_i <= 0
+      empty = headers[CONTENT_LENGTH].to_i <= 0
 
       # client or server error, or explicit message
       if (status.to_i >= 400 && empty) || env["rack.showstatus.detail"]
-        req = Rack::Request.new(env)
+        # This double assignment is to prevent an "unused variable" warning on
+        # Ruby 1.9.3.  Yes, it is dumb, but I don't like Ruby yelling at me.
+        req = req = Rack::Request.new(env)
+
         message = Rack::Utils::HTTP_STATUS_CODES[status.to_i] || status.to_s
-        detail = env["rack.showstatus.detail"] || message
+
+        # This double assignment is to prevent an "unused variable" warning on
+        # Ruby 1.9.3.  Yes, it is dumb, but I don't like Ruby yelling at me.
+        detail = detail = env["rack.showstatus.detail"] || message
+
         body = @template.result(binding)
         size = Rack::Utils.bytesize(body)
-        [status, headers.merge("Content-Type" => "text/html", "Content-Length" => size.to_s), [body]]
+        [status, headers.merge(CONTENT_TYPE => "text/html", CONTENT_LENGTH => size.to_s), [body]]
       else
         [status, headers, body]
       end
@@ -89,7 +96,7 @@ TEMPLATE = <<'HTML'
     </table>
   </div>
   <div id="info">
-    <p><%= detail %></p>
+    <p><%=h detail %></p>
   </div>
 
   <div id="explanation">

data/lib/rack/static.rb

@@ -1,38 +1,150 @@
 module Rack
 
   # The Rack::Static middleware intercepts requests for static files
-  # (javascript files, images, stylesheets, etc) based on the url prefixes
-  # passed in the options, and serves them using a Rack::File object. This
-  # allows a Rack stack to serve both static and dynamic content.
+  # (javascript files, images, stylesheets, etc) based on the url prefixes or
+  # route mappings passed in the options, and serves them using a Rack::File
+  # object. This allows a Rack stack to serve both static and dynamic content.
   #
   # Examples:
+  #
+  # Serve all requests beginning with /media from the "media" folder located
+  # in the current directory (ie media/*):
+  #
   #     use Rack::Static, :urls => ["/media"]
-  #     will serve all requests beginning with /media from the "media" folder
-  #     located in the current directory (ie media/*).
+  #
+  # Serve all requests beginning with /css or /images from the folder "public"
+  # in the current directory (ie public/css/* and public/images/*):
   #
   #     use Rack::Static, :urls => ["/css", "/images"], :root => "public"
-  #     will serve all requests beginning with /css or /images from the folder
-  #     "public" in the current directory (ie public/css/* and public/images/*)
-
+  #
+  # Serve all requests to / with "index.html" from the folder "public" in the
+  # current directory (ie public/index.html):
+  #
+  #     use Rack::Static, :urls => {"/" => 'index.html'}, :root => 'public'
+  #
+  # Serve all requests normally from the folder "public" in the current
+  # directory but uses index.html as default route for "/"
+  #
+  #     use Rack::Static, :urls => [""], :root => 'public', :index =>
+  #     'index.html'
+  #
+  # Set custom HTTP Headers for based on rules:
+  #
+  #     use Rack::Static, :root => 'public',
+  #         :header_rules => [
+  #           [rule, {header_field => content, header_field => content}],
+  #           [rule, {header_field => content}]
+  #         ]
+  #
+  #  Rules for selecting files:
+  #
+  #  1) All files
+  #     Provide the :all symbol
+  #     :all => Matches every file
+  #
+  #  2) Folders
+  #     Provide the folder path as a string
+  #     '/folder' or '/folder/subfolder' => Matches files in a certain folder
+  #
+  #  3) File Extensions
+  #     Provide the file extensions as an array
+  #     ['css', 'js'] or %w(css js) => Matches files ending in .css or .js
+  #
+  #  4) Regular Expressions / Regexp
+  #     Provide a regular expression
+  #     %r{\.(?:css|js)\z} => Matches files ending in .css or .js
+  #     /\.(?:eot|ttf|otf|woff2|woff|svg)\z/ => Matches files ending in
+  #       the most common web font formats (.eot, .ttf, .otf, .woff2, .woff, .svg)
+  #       Note: This Regexp is available as a shortcut, using the :fonts rule
+  #
+  #  5) Font Shortcut
+  #     Provide the :fonts symbol
+  #     :fonts => Uses the Regexp rule stated right above to match all common web font endings
+  #
+  #  Rule Ordering:
+  #    Rules are applied in the order that they are provided.
+  #    List rather general rules above special ones.
+  #
+  #  Complete example use case including HTTP header rules:
+  #
+  #     use Rack::Static, :root => 'public',
+  #         :header_rules => [
+  #           # Cache all static files in public caches (e.g. Rack::Cache)
+  #           #  as well as in the browser
+  #           [:all, {'Cache-Control' => 'public, max-age=31536000'}],
+  #
+  #           # Provide web fonts with cross-origin access-control-headers
+  #           #  Firefox requires this when serving assets using a Content Delivery Network
+  #           [:fonts, {'Access-Control-Allow-Origin' => '*'}]
+  #         ]
+  #
   class Static
 
     def initialize(app, options={})
       @app = app
       @urls = options[:urls] || ["/favicon.ico"]
+      @index = options[:index]
       root = options[:root] || Dir.pwd
+
+      # HTTP Headers
+      @header_rules = options[:header_rules] || []
+      # Allow for legacy :cache_control option while prioritizing global header_rules setting
+      @header_rules.insert(0, [:all, {'Cache-Control' => options[:cache_control]}]) if options[:cache_control]
+
       @file_server = Rack::File.new(root)
     end
 
+    def overwrite_file_path(path)
+      @urls.kind_of?(Hash) && @urls.key?(path) || @index && path =~ /\/$/
+    end
+
+    def route_file(path)
+      @urls.kind_of?(Array) && @urls.any? { |url| path.index(url) == 0 }
+    end
+
+    def can_serve(path)
+      route_file(path) || overwrite_file_path(path)
+    end
+
     def call(env)
-      path = env["PATH_INFO"]
-      can_serve = @urls.any? { |url| path.index(url) == 0 }
+      path = env[PATH_INFO]
+
+      if can_serve(path)
+        env["PATH_INFO"] = (path =~ /\/$/ ? path + @index : @urls[path]) if overwrite_file_path(path)
+        path = env["PATH_INFO"]
+        response = @file_server.call(env)
 
-      if can_serve
-        @file_server.call(env)
+        headers = response[1]
+        applicable_rules(path).each do |rule, new_headers|
+          new_headers.each { |field, content| headers[field] = content }
+        end
+
+        response
       else
         @app.call(env)
       end
     end
 
+    # Convert HTTP header rules to HTTP headers
+    def applicable_rules(path)
+      @header_rules.find_all do |rule, new_headers|
+        case rule
+        when :all
+          true
+        when :fonts
+          path =~ /\.(?:ttf|otf|eot|woff2|woff|svg)\z/
+        when String
+          path = ::Rack::Utils.unescape(path)
+          path.start_with?(rule) || path.start_with?('/' + rule)
+        when Array
+          path =~ /\.(#{rule.join('|')})\z/
+        when Regexp
+          path =~ rule
+        else
+          false
+        end
+      end
+    end
+
   end
 end

data/lib/rack/tempfile_reaper.rb

@@ -0,0 +1,22 @@
+require 'rack/body_proxy'
+
+module Rack
+
+  # Middleware tracks and cleans Tempfiles created throughout a request (i.e. Rack::Multipart)
+  # Ideas/strategy based on posts by Eric Wong and Charles Oliver Nutter
+  # https://groups.google.com/forum/#!searchin/rack-devel/temp/rack-devel/brK8eh-MByw/sw61oJJCGRMJ
+  class TempfileReaper
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env['rack.tempfiles'] ||= []
+      status, headers, body = @app.call(env)
+      body_proxy = BodyProxy.new(body) do
+        env['rack.tempfiles'].each { |f| f.close! } unless env['rack.tempfiles'].nil?
+      end
+      [status, headers, body_proxy]
+    end
+  end
+end

data/lib/rack/urlmap.rb

@@ -12,6 +12,9 @@ module Rack
   # first, since they are most specific.
 
   class URLMap
+    NEGATIVE_INFINITY = -1.0 / 0.0
+    INFINITY = 1.0 / 0.0
+
     def initialize(map = {})
       remap(map)
     end
@@ -27,29 +30,60 @@ module Rack
         unless location[0] == ?/
           raise ArgumentError, "paths need to start with /"
         end
+
         location = location.chomp('/')
         match = Regexp.new("^#{Regexp.quote(location).gsub('/', '/+')}(.*)", nil, 'n')
 
         [host, location, match, app]
-      }.sort_by { |(h, l, m, a)| [h ? -h.size : (-1.0 / 0.0), -l.size] }  # Longest path first
+      }.sort_by do |(host, location, _, _)|
+        [host ? -host.size : INFINITY, -location.size]
+      end
     end
 
     def call(env)
-      path = env["PATH_INFO"].to_s
+      path = env[PATH_INFO]
       script_name = env['SCRIPT_NAME']
-      hHost, sName, sPort = env.values_at('HTTP_HOST','SERVER_NAME','SERVER_PORT')
-      @mapping.each { |host, location, match, app|
-        next unless (hHost == host || sName == host \
-          || (host.nil? && (hHost == sName || hHost == sName+':'+sPort)))
-        next unless path =~ match && rest = $1
-        next unless rest.empty? || rest[0] == ?/
-
-        return app.call(
-          env.merge(
-            'SCRIPT_NAME' => (script_name + location),
-            'PATH_INFO'   => rest))
-      }
-      [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]
+      hHost = env['HTTP_HOST']
+      sName = env['SERVER_NAME']
+      sPort = env['SERVER_PORT']
+
+      @mapping.each do |host, location, match, app|
+        unless casecmp?(hHost, host) \
+            || casecmp?(sName, host) \
+            || (!host && (casecmp?(hHost, sName) ||
+                          casecmp?(hHost, sName+':'+sPort)))
+          next
+        end
+
+        next unless m = match.match(path.to_s)
+
+        rest = m[1]
+        next unless !rest || rest.empty? || rest[0] == ?/
+
+        env['SCRIPT_NAME'] = (script_name + location)
+        env['PATH_INFO'] = rest
+
+        return app.call(env)
+      end
+
+      [404, {CONTENT_TYPE => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]
+
+    ensure
+      env['PATH_INFO'] = path
+      env['SCRIPT_NAME'] = script_name
+    end
+
+    private
+    def casecmp?(v1, v2)
+      # if both nil, or they're the same string
+      return true if v1 == v2
+
+      # if either are nil... (but they're not the same)
+      return false if v1.nil?
+      return false if v2.nil?
+
+      # otherwise check they're not case-insensitive the same
+      v1.casecmp(v2).zero?
     end
   end
 end