corntrace-rack-contrib 1.0.2

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/garbagecollector.rb

@@ -0,0 +1,14 @@
+module Rack
+  # Forces garbage collection after each request.
+  class GarbageCollector
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    ensure
+      GC.start
+    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

@@ -0,0 +1,78 @@
+module Rack
+
+  # A Rack middleware for providing JSON-P support.
+  #
+  # Full credit to Flinn Mueller (http://actsasflinn.com/) for this contribution.
+  #
+  class JSONP
+    include Rack::Utils
+
+    def initialize(app)
+      @app = app
+    end
+
+    # Proxies the request to the application, stripping out the JSON-P callback
+    # method and padding the response with the appropriate callback format if
+    # the returned body is application/json
+    #
+    # Changes nothing if no <tt>callback</tt> param is specified.
+    #
+    def call(env)
+      status, headers, response = @app.call(env)
+
+      headers = HeaderHash.new(headers)
+      request = Rack::Request.new(env)
+      
+      if is_json?(headers) && has_callback?(request)
+        status = translate_error_code!(status, response)
+        response = pad(request.params.delete('callback'), response)
+
+        # No longer json, its javascript!
+        headers['Content-Type'].gsub!('json', 'javascript')
+        
+        # Set new Content-Length, if it was set before we mutated the response body
+        if headers['Content-Length']
+          length = response.to_ary.inject(0) { |len, part| len + bytesize(part) }
+          headers['Content-Length'] = length.to_s
+        end
+      end
+      [status, headers, response]
+    end
+    
+    private
+    
+    def is_json?(headers)
+      headers['Content-Type'].include?('application/json')
+    end
+    
+    def has_callback?(request)
+      request.params.include?('callback')
+    end
+
+    # Pads the response with the appropriate callback format according to the
+    # JSON-P spec/requirements.
+    #
+    # The Rack response spec indicates that it should be enumerable. The
+    # method of combining all of the data into a single string makes sense
+    # since JSON is returned as a full string.
+    #
+    def pad(callback, response, body = "")
+      response.each{ |s| body << s.to_s }
+      ["#{callback}(#{body})"]
+    end
+    
+    # Translate status code 40x and 50x to a json string in response, and change
+    # status code to 200. That because the jsonp's implemetation could not handler 
+    # http status code when error occured, which could be meaningful in webservice.
+    def translate_error_code!(status, response)
+      if status % 400 == 4 || status % 500 == 5
+        response.slice(1..-1)  # keep the first element, delete the others
+        response[0] = %Q|{"errorCode":#{status}}|
+        status = 200
+      else
+        status
+      end
+    end
+
+  end
+end

data/lib/rack/contrib/lighttpd_script_name_fix.rb

@@ -0,0 +1,16 @@
+module Rack
+  # Lighttpd sets the wrong SCRIPT_NAME and PATH_INFO if you mount your
+  # FastCGI app at "/". This middleware fixes this issue.
+
+  class LighttpdScriptNameFix
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["PATH_INFO"] = env["SCRIPT_NAME"].to_s + env["PATH_INFO"].to_s
+      env["SCRIPT_NAME"] = ""
+      @app.call(env)
+    end
+  end
+end

data/lib/rack/contrib/locale.rb

@@ -0,0 +1,31 @@
+require 'i18n'
+
+module Rack
+  class Locale
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      old_locale = I18n.locale
+      locale = nil
+
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4
+      if lang = env["HTTP_ACCEPT_LANGUAGE"]
+        lang = lang.split(",").map { |l|
+          l += ';q=1.0' unless l =~ /;q=\d+\.\d+$/
+          l.split(';q=')
+        }.first
+        locale = lang.first.split("-").first
+      else
+        locale = I18n.default_locale
+      end
+
+      locale = env['rack.locale'] = I18n.locale = locale.to_s
+      status, headers, body = @app.call(env)
+      headers['Content-Language'] = locale
+      I18n.locale = old_locale
+      [status, headers, body]
+    end
+  end
+end

data/lib/rack/contrib/mailexceptions.rb

@@ -0,0 +1,120 @@
+require 'net/smtp'
+require 'tmail'
+require 'erb'
+
+module Rack
+  # Catches all exceptions raised from the app it wraps and
+  # sends a useful email with the exception, stacktrace, and
+  # contents of the environment.
+
+  class MailExceptions
+    attr_reader :config
+
+    def initialize(app)
+      @app = app
+      @config = {
+        :to      => nil,
+        :from    => ENV['USER'] || 'rack',
+        :subject => '[exception] %s',
+        :smtp    => {
+          :server         => 'localhost',
+          :domain         => 'localhost',
+          :port           => 25,
+          :authentication => :login,
+          :user_name      => nil,
+          :password       => nil
+        }
+      }
+      @template = ERB.new(TEMPLATE)
+      yield self if block_given?
+    end
+
+    def call(env)
+      status, headers, body =
+        begin
+          @app.call(env)
+        rescue => boom
+          # TODO don't allow exceptions from send_notification to
+          # propogate
+          send_notification boom, env
+          raise
+        end
+      send_notification env['mail.exception'], env if env['mail.exception']
+      [status, headers, body]
+    end
+
+    %w[to from subject].each do |meth|
+      define_method(meth) { |value| @config[meth.to_sym] = value }
+    end
+
+    def smtp(settings={})
+      @config[:smtp].merge! settings
+    end
+
+  private
+    def generate_mail(exception, env)
+      mail = TMail::Mail.new
+      mail.to = Array(config[:to])
+      mail.from = config[:from]
+      mail.subject = config[:subject] % [exception.to_s]
+      mail.date = Time.now
+      mail.set_content_type 'text/plain'
+      mail.charset = 'UTF-8'
+      mail.body = @template.result(binding)
+      mail
+    end
+
+    def send_notification(exception, env)
+      mail = generate_mail(exception, env)
+      smtp = config[:smtp]
+      env['mail.sent'] = true
+      return if smtp[:server] == 'example.com'
+
+      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
+      end
+    end
+
+    def extract_body(env)
+      if io = env['rack.input']
+        io.rewind if io.respond_to?(:rewind)
+        io.read
+      end
+    end
+
+    TEMPLATE = (<<-'EMAIL').gsub(/^ {4}/, '')
+    A <%= exception.class.to_s %> occured: <%= exception.to_s %>
+    <% if body = extract_body(env) %>
+
+    ===================================================================
+    Request Body:
+    ===================================================================
+
+    <%= body.gsub(/^/, '  ') %>
+    <% end %>
+
+    ===================================================================
+    Rack Environment:
+    ===================================================================
+
+      PID:                     <%= $$ %>
+      PWD:                     <%= Dir.getwd %>
+
+      <%= env.to_a.
+        sort{|a,b| a.first <=> b.first}.
+        map{ |k,v| "%-25s%p" % [k+':', v] }.
+        join("\n  ") %>
+
+    <% if exception.respond_to?(:backtrace) %>
+    ===================================================================
+    Backtrace:
+    ===================================================================
+
+      <%= exception.backtrace.join("\n  ") %>
+    <% end %>
+    EMAIL
+
+  end
+end

data/lib/rack/contrib/nested_params.rb

@@ -0,0 +1,143 @@
+require 'cgi'
+require 'strscan'
+
+module Rack
+  # Rack middleware for parsing POST/PUT body data into nested parameters
+  class NestedParams
+
+    CONTENT_TYPE = 'CONTENT_TYPE'.freeze
+    POST_BODY = 'rack.input'.freeze
+    FORM_INPUT = 'rack.request.form_input'.freeze
+    FORM_HASH = 'rack.request.form_hash'.freeze
+    FORM_VARS = 'rack.request.form_vars'.freeze
+
+    # supported content type
+    URL_ENCODED = 'application/x-www-form-urlencoded'.freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if form_vars = env[FORM_VARS]
+        env[FORM_HASH] = parse_query_parameters(form_vars)
+      elsif env[CONTENT_TYPE] == URL_ENCODED
+        post_body = env[POST_BODY]
+        env[FORM_INPUT] = post_body
+        env[FORM_HASH] = parse_query_parameters(post_body.read)
+        post_body.rewind if post_body.respond_to?(:rewind)
+      end
+      @app.call(env)
+    end
+
+    ## the rest is nabbed from Rails ##
+
+    def parse_query_parameters(query_string)
+      return {} if query_string.nil? or query_string.empty?
+
+      pairs = query_string.split('&').collect do |chunk|
+        next if chunk.empty?
+        key, value = chunk.split('=', 2)
+        next if key.empty?
+        value = value.nil? ? nil : CGI.unescape(value)
+        [ CGI.unescape(key), value ]
+      end.compact
+
+      UrlEncodedPairParser.new(pairs).result
+    end
+
+    class UrlEncodedPairParser < StringScanner
+      attr_reader :top, :parent, :result
+
+      def initialize(pairs = [])
+        super('')
+        @result = {}
+        pairs.each { |key, value| parse(key, value) }
+      end
+
+      KEY_REGEXP = %r{([^\[\]=&]+)}
+      BRACKETED_KEY_REGEXP = %r{\[([^\[\]=&]+)\]}
+
+      # Parse the query string
+      def parse(key, value)
+        self.string = key
+        @top, @parent = result, nil
+
+        # First scan the bare key
+        key = scan(KEY_REGEXP) or return
+        key = post_key_check(key)
+
+        # Then scan as many nestings as present
+        until eos?
+          r = scan(BRACKETED_KEY_REGEXP) or return
+          key = self[1]
+          key = post_key_check(key)
+        end
+
+        bind(key, value)
+      end
+
+      private
+        # After we see a key, we must look ahead to determine our next action. Cases:
+        #
+        #   [] follows the key. Then the value must be an array.
+        #   = follows the key. (A value comes next)
+        #   & or the end of string follows the key. Then the key is a flag.
+        #   otherwise, a hash follows the key.
+        def post_key_check(key)
+          if scan(/\[\]/) # a[b][] indicates that b is an array
+            container(key, Array)
+            nil
+          elsif check(/\[[^\]]/) # a[b] indicates that a is a hash
+            container(key, Hash)
+            nil
+          else # End of key? We do nothing.
+            key
+          end
+        end
+
+        # Add a container to the stack.
+        def container(key, klass)
+          type_conflict! klass, top[key] if top.is_a?(Hash) && top.key?(key) && ! top[key].is_a?(klass)
+          value = bind(key, klass.new)
+          type_conflict! klass, value unless value.is_a?(klass)
+          push(value)
+        end
+
+        # Push a value onto the 'stack', which is actually only the top 2 items.
+        def push(value)
+          @parent, @top = @top, value
+        end
+
+        # Bind a key (which may be nil for items in an array) to the provided value.
+        def bind(key, value)
+          if top.is_a? Array
+            if key
+              if top[-1].is_a?(Hash) && ! top[-1].key?(key)
+                top[-1][key] = value
+              else
+                top << {key => value}
+              end
+              push top.last
+              return top[key]
+            else
+              top << value
+              return value
+            end
+          elsif top.is_a? Hash
+            key = CGI.unescape(key)
+            parent << (@top = {}) if top.key?(key) && parent.is_a?(Array)
+            top[key] ||= value
+            return top[key]
+          else
+            raise ArgumentError, "Don't know what to do: top is #{top.inspect}"
+          end
+        end
+
+        def type_conflict!(klass, value)
+          raise TypeError, "Conflicting types for parameter containers. Expected an instance of #{klass} but found an instance of #{value.class}. This can be caused by colliding Array and Hash parameters like qs[]=value&qs[key]=value. (The parameters received were #{value.inspect}.)"
+        end
+    end
+
+  end
+end

data/lib/rack/contrib/not_found.rb

@@ -0,0 +1,18 @@
+module Rack
+  # Rack::NotFound is a default endpoint. Initialize with the path to
+  # your 404 page.
+
+  class NotFound
+    F = ::File
+
+    def initialize(path)
+      file = F.expand_path(path)
+      @content = F.read(file)
+      @length = @content.size.to_s
+    end
+
+    def call(env)
+      [404, {'Content-Type' => 'text/html', 'Content-Length' => @length}, [@content]]
+    end
+  end
+end

data/lib/rack/contrib/post_body_content_type_parser.rb

@@ -0,0 +1,40 @@
+begin
+  require 'json'
+rescue LoadError => e
+  require 'json/pure'
+end
+
+module Rack
+
+  # 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.
+  #
+  class PostBodyContentTypeParser
+
+    # Constants
+    #
+    CONTENT_TYPE = 'CONTENT_TYPE'.freeze
+    POST_BODY = 'rack.input'.freeze
+    FORM_INPUT = 'rack.request.form_input'.freeze
+    FORM_HASH = 'rack.request.form_hash'.freeze
+
+    # Supported Content-Types
+    #
+    APPLICATION_JSON = 'application/json'.freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      case env[CONTENT_TYPE]
+      when APPLICATION_JSON
+        env.update(FORM_HASH => JSON.parse(env[POST_BODY].read), FORM_INPUT => env[POST_BODY])
+      end
+      @app.call(env)
+    end
+
+  end
+end

data/lib/rack/contrib/proctitle.rb

@@ -0,0 +1,30 @@
+module Rack
+  # Middleware to update the process title ($0) with information about the
+  # current request. Based loosely on:
+  # - http://purefiction.net/mongrel_proctitle/
+  # - http://github.com/grempe/thin-proctitle/tree/master
+  #
+  # NOTE: This will not work properly in a multi-threaded environment.
+  class ProcTitle
+    F = ::File
+    PROGNAME = F.basename($0)
+
+    def initialize(app)
+      @app = app
+      @appname = Dir.pwd.split('/').reverse.
+        find { |name| name !~ /^(\d+|current|releases)$/ } || PROGNAME
+      @requests = 0
+      $0 = "#{PROGNAME} [#{@appname}] init ..."
+    end
+
+    def call(env)
+      host, port = env['SERVER_NAME'], env['SERVER_PORT']
+      meth, path = env['REQUEST_METHOD'], env['PATH_INFO']
+      @requests += 1
+      $0 = "#{PROGNAME} [#{@appname}/#{port}] (#{@requests}) " \
+           "#{meth} #{path}"
+
+      @app.call(env)
+    end
+  end
+end

data/lib/rack/contrib/profiler.rb

@@ -0,0 +1,108 @@
+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.
+  class Profiler
+    MODES = %w(
+      process_time
+      wall_time
+      cpu_time
+      allocations
+      memory
+      gc_runs
+      gc_time
+    )
+
+    DEFAULT_PRINTER = RubyProf::CallTreePrinter
+    DEFAULT_CONTENT_TYPE = 'application/octet-stream'
+
+    PRINTER_CONTENT_TYPE = {
+      RubyProf::FlatPrinter => 'text/plain',
+      RubyProf::GraphPrinter => 'text/plain',
+      RubyProf::GraphHtmlPrinter => 'text/html'
+    }
+
+    # Accepts a :printer => [:call_tree|:graph_html|:graph|:flat] option
+    # defaulting to :call_tree.
+    def initialize(app, options = {})
+      @app = app
+      @printer = parse_printer(options[:printer])
+      @times = (options[:times] || 1).to_i
+    end
+
+    def call(env)
+      if mode = profiling?(env)
+        profile(env, mode)
+      else
+        @app.call(env)
+      end
+    end
+
+    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
+          end
+        end
+      end
+
+      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
+
+      def print(printer, result)
+        body = StringIO.new
+        printer.new(result).print(body, :min_percent => 0.01)
+        body.rewind
+        body
+      end
+
+      def headers(printer, env, mode)
+        headers = { 'Content-Type' => PRINTER_CONTENT_TYPE[printer] || DEFAULT_CONTENT_TYPE }
+        if printer == RubyProf::CallTreePrinter
+          filename = ::File.basename(env['PATH_INFO'])
+          headers['Content-Disposition'] =
+            %(attachment; filename="#{filename}.#{mode}.tree")
+        end
+        headers
+      end
+
+      def parse_printer(printer)
+        if printer.nil?
+          DEFAULT_PRINTER
+        elsif printer.is_a?(Class)
+          printer
+        else
+          name = "#{camel_case(printer)}Printer"
+          if RubyProf.const_defined?(name)
+            RubyProf.const_get(name)
+          else
+            DEFAULT_PRINTER
+          end
+        end
+      end
+
+      def camel_case(word)
+        word.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
+      end
+  end
+end