rack-contrib 0.9.2 → 1.0.0

data/AUTHORS

@@ -0,0 +1,26 @@
+Ryan Tomayko <rtomayko@gmail.com>
+Joshua Peek <josh@joshpeek.com>
+Jeremy Kemper <jeremy@bitsweat.net>
+mynyml <mynyml@gmail.com>
+Cameron Walters <cameron.walters@gmail.com>
+Jon Crosby <jon@joncrosby.me>
+Matt Todd <chiology@gmail.com>
+Pirmin Kalberer <pka@sourcepole.ch>
+Rune Botten <rbotten@gmail.com>
+Pratik Naik <pratiknaik@gmail.com>
+Paul Sadauskas <psadauskas@gmail.com>
+Jeremy Evans <code@jeremyevans.net>
+Michael Fellinger <m.fellinger@gmail.com>
+Geoff Buesing <gbuesing@gmail.com>
+Nicolas Mérouze <nicolas.merouze@gmail.com>
+Cyril Rohr <cyril.rohr@irisa.fr>
+Harry Vangberg <harry@vangberg.name>
+James Rosen <jrosen@mitre.org>
+Mislav Marohnić <mislav.marohnic@gmail.com>
+Ben Brinckerhoff <ben@devver.net>
+Rafael Souza <rafael.ssouza@gmail.com>
+Stephen Delano <sdelano@sdelano-air.(none)>
+TJ Holowaychuk <tj@vision-media.ca>
+anupom syam <anupom.syam@gmail.com>
+ichverstehe <ichverstehe@gmail.com>
+kubicek <jiri@kubicek.cz>

data/README.rdoc

@@ -3,7 +3,6 @@
 This package includes a variety of add-on components for Rack, a Ruby web server
 interface:
 
-* Rack::ETag - Automatically sets the ETag header on all String bodies.
 * Rack::JSONP - Adds JSON-P support by stripping out the callback param
   and padding the response with the appropriate callback format.
 * Rack::LighttpdScriptNameFix - Fixes how lighttpd sets the SCRIPT_NAME
@@ -25,6 +24,8 @@ interface:
   from file.
 * Rack::Signals - Installs signal handlers that are safely processed after
   a request
+* Rack::StaticCache - Modifies the response headers to facilitiate client and proxy caching for
+  static files that minimizes http requests and improves overall load times for second time visitors.
 * Rack::TimeZone - Detects the clients timezone using JavaScript and sets
   a variable in Rack's environment with the offset from UTC.
 * Rack::Evil - Lets the rack application return a response to the client from any place.
@@ -43,6 +44,9 @@ interface:
 * Rack::AcceptFormat - Adds a format extension at the end of the URI when there is none, corresponding to the mime-type given in the Accept HTTP header.
 * Rack::HostMeta - Configures /host-meta using a block
 * Rack::Cookies - Adds simple cookie jar hash to env
+* Rack::Access - Limit access based on IP address
+* Rack::ResponseHeaders - Manipulate response headers object at runtime
+* Rack::SimpleEndpoint - Create simple endpoints with routing rules, similar to Sinatra actions
 
 === Use
 
@@ -50,9 +54,9 @@ Git is the quickest way to the rack-contrib sources:
 
   git clone git://github.com/rack/rack-contrib.git
 
-Gems are currently available from GitHub clones:
+Gems are available too:
 
-  gem install rack-rack-contrib --source=http://gems.github.com/
+  gem install rack-contrib
 
 Requiring 'rack/contrib' will add autoloads to the Rack modules for all of the
 components included. The following example shows what a simple rackup

data/Rakefile

@@ -42,8 +42,8 @@ task :rdoc => ["RDOX"]
 
 # PACKAGING =================================================================
 
-# load gemspec like github's gem builder to surface any SAFE issues.
-require 'rubygems/specification'
+require 'rubygems'
+# load gemspec
 $spec = eval(File.read('rack-contrib.gemspec'))
 
 def package(ext='')
@@ -69,14 +69,6 @@ file package('.tar.gz') => %w[pkg/] + $spec.files do |f|
   sh "git archive --format=tar HEAD | gzip > #{f.name}"
 end
 
-desc 'Publish gem and tarball to rubyforge'
-task 'publish:gem' => [package('.gem'), package('.tar.gz')] do |t|
-  sh <<-end
-    rubyforge add_release rack rack-contrib #{$spec.version} #{package('.gem')} &&
-    rubyforge add_file    rack rack-contrib #{$spec.version} #{package('.tar.gz')}
-  end
-end
-
 # GEMSPEC ===================================================================
 
 file 'rack-contrib.gemspec' => FileList['{lib,test}/**','Rakefile', 'README.rdoc'] do |f|

data/lib/rack/contrib.rb

@@ -8,11 +8,13 @@ module Rack
   end
 
   autoload :AcceptFormat,               "rack/contrib/accept_format"
+  autoload :Access,                     "rack/contrib/access"
   autoload :BounceFavicon,              "rack/contrib/bounce_favicon"
   autoload :Cookies,                    "rack/contrib/cookies"
   autoload :CSSHTTPRequest,             "rack/contrib/csshttprequest"
   autoload :Deflect,                    "rack/contrib/deflect"
   autoload :ETag,                       "rack/contrib/etag"
+  autoload :ExpectationCascade,         "rack/contrib/expectation_cascade"
   autoload :GarbageCollector,           "rack/contrib/garbagecollector"
   autoload :JSONP,                      "rack/contrib/jsonp"
   autoload :LighttpdScriptNameFix,      "rack/contrib/lighttpd_script_name_fix"
@@ -21,8 +23,11 @@ module Rack
   autoload :PostBodyContentTypeParser,  "rack/contrib/post_body_content_type_parser"
   autoload :ProcTitle,                  "rack/contrib/proctitle"
   autoload :Profiler,                   "rack/contrib/profiler"
+  autoload :ResponseHeaders,            "rack/contrib/response_headers"
+  autoload :Runtime,                    "rack/contrib/runtime"
   autoload :Sendfile,                   "rack/contrib/sendfile"
   autoload :Signals,                    "rack/contrib/signals"
+  autoload :SimpleEndpoint,             "rack/contrib/simple_endpoint"
   autoload :TimeZone,                   "rack/contrib/time_zone"
   autoload :Evil,                       "rack/contrib/evil"
   autoload :Callbacks,                  "rack/contrib/callbacks"
@@ -31,4 +36,5 @@ module Rack
   autoload :NotFound,                   "rack/contrib/not_found"
   autoload :ResponseCache,              "rack/contrib/response_cache"
   autoload :RelativeRedirect,           "rack/contrib/relative_redirect"
+  autoload :StaticCache,           	"rack/contrib/static_cache"
 end

data/lib/rack/contrib/access.rb

@@ -0,0 +1,85 @@
+require "ipaddr"
+
+module Rack
+
+  ##
+  # Rack middleware for limiting access based on IP address
+  #
+  #
+  # === Options:
+  #
+  #   path => ipmasks      ipmasks: Array of remote addresses which are allowed to access
+  #
+  # === Examples:
+  #
+  #  use Rack::Access, '/backend' => [ '127.0.0.1',  '192.168.1.0/24' ]
+  #
+  #
+
+  class Access
+
+    attr_reader :options
+
+    def initialize(app, options = {})
+      @app = app
+      mapping = options.empty? ? {"/" => ["127.0.0.1"]} : options
+      @mapping = remap(mapping)
+    end
+
+    def remap(mapping)
+      mapping.map { |location, ipmasks|
+        if location =~ %r{\Ahttps?://(.*?)(/.*)}
+          host, location = $1, $2
+        else
+          host = nil
+        end
+
+        unless location[0] == ?/
+          raise ArgumentError, "paths need to start with /"
+        end
+        location = location.chomp('/')
+        match = Regexp.new("^#{Regexp.quote(location).gsub('/', '/+')}(.*)", nil, 'n')
+
+        ipmasks.collect! do |ipmask|
+          ipmask.is_a?(IPAddr) ? ipmask : IPAddr.new(ipmask)
+        end
+        [host, location, match, ipmasks]
+      }.sort_by { |(h, l, m, a)| [h ? -h.size : (-1.0 / 0.0), -l.size] }  # Longest path first
+    end
+
+    def call(env)
+      @original_request = Request.new(env)
+      ipmasks = ipmasks_for_path(env)
+      return forbidden! unless ip_authorized?(ipmasks)
+      status, headers, body = @app.call(env)
+      [status, headers, body]
+    end
+
+    def ipmasks_for_path(env)
+      path = env["PATH_INFO"].to_s
+      hHost, sName, sPort = env.values_at('HTTP_HOST','SERVER_NAME','SERVER_PORT')
+      @mapping.each do |host, location, match, ipmasks|
+        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 ipmasks
+      end
+      nil
+    end
+
+    def forbidden!
+      [403, { 'Content-Type' => 'text/html', 'Content-Length' => '0' }, '']
+    end
+
+    def ip_authorized?(ipmasks)
+      return true if ipmasks.nil?
+
+      ipmasks.any? do |ip_mask|
+        ip_mask.include?(IPAddr.new(@original_request.ip))
+      end
+    end
+
+  end
+end

data/lib/rack/contrib/cookies.rb

@@ -0,0 +1,50 @@
+module Rack
+  class Cookies
+    class CookieJar < Hash
+      def initialize(cookies)
+        @set_cookies = {}
+        @delete_cookies = {}
+        super()
+        update(cookies)
+      end
+
+      def [](name)
+        super(name.to_s)
+      end
+
+      def []=(key, options)
+        unless options.is_a?(Hash)
+          options = { :value => options }
+        end
+
+        options[:path] ||= '/'
+        @set_cookies[key] = options
+        super(key.to_s, options[:value])
+      end
+
+      def delete(key, options = {})
+        options[:path] ||= '/'
+        @delete_cookies[key] = options
+        super(key.to_s)
+      end
+
+      def finish!(resp)
+        @set_cookies.each { |k, v| resp.set_cookie(k, v) }
+        @delete_cookies.each { |k, v| resp.delete_cookie(k, v) }
+      end
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      req = Request.new(env)
+      env['rack.cookies'] = cookies = CookieJar.new(req.cookies)
+      status, headers, body = @app.call(env)
+      resp = Response.new(body, status, headers)
+      cookies.finish!(resp)
+      resp.to_a
+    end
+  end
+end

data/lib/rack/contrib/expectation_cascade.rb

@@ -0,0 +1,32 @@
+module Rack
+  class ExpectationCascade
+    Expect = "Expect".freeze
+    ContinueExpectation = "100-continue".freeze
+
+    ExpectationFailed = [417, {"Content-Type" => "text/html"}, []].freeze
+    NotFound = [404, {"Content-Type" => "text/html"}, []].freeze
+
+    attr_reader :apps
+
+    def initialize
+      @apps = []
+      yield self if block_given?
+    end
+
+    def call(env)
+      set_expectation = env[Expect] != ContinueExpectation
+      env[Expect] = ContinueExpectation if set_expectation
+      @apps.each do |app|
+        result = app.call(env)
+        return result unless result[0].to_i == 417
+      end
+      set_expectation ? NotFound : ExpectationFailed
+    ensure
+      env.delete(Expect) if set_expectation
+    end
+
+    def <<(app)
+      @apps << app
+    end
+  end
+end

data/lib/rack/contrib/host_meta.rb

@@ -0,0 +1,47 @@
+module Rack
+
+  # Rack middleware implementing the IETF draft: "Host Metadata for the Web"
+  # including support for Link-Pattern elements as described in the IETF draft:
+  # "Link-based Resource Descriptor Discovery."
+  #
+  # Usage:
+  #  use Rack::HostMeta do
+  #    link :uri => '/robots.txt', :rel => 'robots'
+  #    link :uri => '/w3c/p3p.xml', :rel => 'privacy', :type => 'application/p3p.xml'
+  #    link :pattern => '{uri};json_schema', :rel => 'describedby', :type => 'application/x-schema+json'
+  #  end
+  #
+  # See also:
+  #   http://tools.ietf.org/html/draft-nottingham-site-meta
+  #   http://tools.ietf.org/html/draft-hammer-discovery
+  #
+  # TODO:
+  #   Accept POST operations allowing downstream services to register themselves
+  #
+  class HostMeta
+    def initialize(app, &block)
+      @app = app
+      @lines = []
+      instance_eval(&block)
+      @response = @lines.join("\n")
+    end
+
+    def call(env)
+      if env['PATH_INFO'] == '/host-meta'
+        [200, {'Content-Type' => 'application/host-meta'}, [@response]]
+      else
+        @app.call(env)
+      end
+    end
+
+    protected
+
+    def link(config)
+      line = config[:uri] ? "Link: <#{config[:uri]}>;" : "Link-Pattern: <#{config[:pattern]}>;"
+      fragments = []
+      fragments << "rel=\"#{config[:rel]}\"" if config[:rel]
+      fragments << "type=\"#{config[:type]}\"" if config[:type]
+      @lines << "#{line} #{fragments.join("; ")}"
+    end
+  end
+end

data/lib/rack/contrib/jsonp.rb

@@ -22,7 +22,7 @@ module Rack
         response = pad(request.params.delete('callback'), response)
         headers['Content-Length'] = response.length.to_s
       end
-      [status, headers, [response]]
+      [status, headers, response]
     end
 
     # Pads the response with the appropriate callback format according to the

data/lib/rack/contrib/mailexceptions.rb

@@ -70,7 +70,7 @@ module Rack
       env['mail.sent'] = true
       return if smtp[:server] == 'example.com'
 
-      Net::SMTP.start smtp[:address], smtp[:port], smtp[:domain], smtp[:user_name], smtp[:password], smtp[:authentication] do |server|
+      Net::SMTP.start smtp[:server], smtp[:port], smtp[:domain], smtp[:user_name], smtp[:password], smtp[:authentication] do |server|
         mail.to.each do |recipient|
           server.send_message mail.to_s, mail.from, recipient
         end

data/lib/rack/contrib/profiler.rb

@@ -44,7 +44,7 @@ module Rack
     private
       def profiling?(env)
         unless RubyProf.running?
-          request = Rack::Request.new(env)
+          request = Rack::Request.new(env.clone)
           if mode = request.params.delete('profile')
             if RubyProf.const_defined?(mode.upcase)
               mode
@@ -60,9 +60,11 @@ module Rack
       def profile(env, mode)
         RubyProf.measure_mode = RubyProf.const_get(mode.upcase)
 
+        GC.enable_stats if GC.respond_to?(:enable_stats)
         result = RubyProf.profile do
           @times.times { @app.call(env) }
         end
+        GC.disable_stats if GC.respond_to?(:disable_stats)
 
         [200, headers(@printer, env, mode), print(@printer, result)]
       end

data/lib/rack/contrib/response_headers.rb

@@ -0,0 +1,24 @@
+module Rack
+  # Allows you to tap into the response headers. Yields a Rack::Utils::HeaderHash
+  # of current response headers to the block. Example:
+  #
+  #   use Rack::ResponseHeaders do |headers|
+  #     headers['X-Foo'] = 'bar'
+  #     headers.delete('X-Baz')
+  #   end
+  #
+  class ResponseHeaders
+    def initialize(app, &block)
+      @app = app
+      @block = block
+    end
+
+    def call(env)
+      response = @app.call(env)
+      headers = Utils::HeaderHash.new(response[1])
+      @block.call(headers)
+      response[1] = headers
+      response
+    end
+  end
+end

data/lib/rack/contrib/runtime.rb

@@ -0,0 +1,31 @@
+
+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
+
+
+

data/lib/rack/contrib/simple_endpoint.rb

@@ -0,0 +1,81 @@
+module Rack
+  # Create simple endpoints with routing rules, similar to Sinatra actions.
+  #
+  # Simplest example:
+  #
+  #   use Rack::SimpleEndpoint, '/ping_monitor' do
+  #     'pong'
+  #   end
+  #
+  # The value returned from the block will be written to the response body, so
+  # the above example will return "pong" when the request path is /ping_monitor.
+  #
+  # HTTP verb requirements can optionally be specified:
+  #
+  #   use Rack::SimpleEndpoint, '/foo' => :get do
+  #     'only GET requests will match'
+  #   end
+  #
+  #   use Rack::SimpleEndpoint, '/bar' => [:get, :post] do
+  #     'only GET and POST requests will match'
+  #   end
+  #
+  # Rack::Request and Rack::Response objects are yielded to block:
+  #
+  #   use Rack::SimpleEndpoint, '/json' do |req, res|
+  #     res['Content-Type'] = 'application/json'
+  #     %({"foo": "#{req[:foo]}"})
+  #   end
+  #
+  # When path is a Regexp, match data object is yielded as third argument to block
+  #
+  #   use Rack::SimpleEndpoint, %r{^/(john|paul|george|ringo)} do |req, res, match|
+  #     "Hello, #{match[1]}"
+  #   end
+  #
+  # A :pass symbol returned from block will not return a response; control will continue down the
+  # Rack stack:
+  #
+  #   use Rack::SimpleEndpoint, '/api_key' do |req, res|
+  #     req.env['myapp.user'].authorized? ? '12345' : :pass
+  #   end
+  #
+  #   # Unauthorized access to /api_key will be handled by PublicApp
+  #   run PublicApp
+  class SimpleEndpoint
+    def initialize(app, arg, &block)
+      @app    = app
+      @path   = extract_path(arg)
+      @verbs  = extract_verbs(arg)
+      @block  = block
+    end
+
+    def call(env)
+      match = match_path(env['PATH_INFO'])
+      if match && valid_method?(env['REQUEST_METHOD'])
+        req, res = Request.new(env), Response.new
+        body = @block.call(req, res, (match unless match == true))
+        body == :pass ? @app.call(env) : (res.write(body); res.finish)
+      else
+        @app.call(env)
+      end
+    end
+    
+    private
+      def extract_path(arg)
+        arg.is_a?(Hash) ? arg.keys.first : arg
+      end
+      
+      def extract_verbs(arg)
+        arg.is_a?(Hash) ? [arg.values.first].flatten.map {|verb| verb.to_s.upcase} : []
+      end
+      
+      def match_path(path)
+        @path.is_a?(Regexp) ? @path.match(path.to_s) : @path == path.to_s
+      end
+      
+      def valid_method?(method)
+        @verbs.empty? || @verbs.include?(method)
+      end
+  end
+end