devver-rack-contrib 0.9.3

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)
+          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

data/lib/rack/contrib/relative_redirect.rb

@@ -0,0 +1,44 @@
+require 'rack'
+
+# Rack::RelativeRedirect is a simple middleware that converts relative paths in
+# redirects in absolute urls, so they conform to RFC2616. It allows the user to
+# specify the absolute path to use (with a sensible default), and handles
+# relative paths (those that don't start with a slash) as well.
+class Rack::RelativeRedirect
+  SCHEME_MAP = {'http'=>'80', 'https'=>'443'}
+  # The default proc used if a block is not provided to .new
+  # Just uses the url scheme of the request and the server name.
+  DEFAULT_ABSOLUTE_PROC = proc do |env, res|
+    port = env['SERVER_PORT']
+    scheme = env['rack.url_scheme']
+    "#{scheme}://#{env['SERVER_NAME']}#{":#{port}" unless SCHEME_MAP[scheme] == port}"
+  end
+
+  # Initialize a new RelativeRedirect object with the given arguments.  Arguments:
+  # * app : The next middleware in the chain.  This is always called.
+  # * &block : If provided, it is called with the environment and the response
+  #   from the next middleware. It should return a string representing the scheme
+  #   and server name (such as 'http://example.org').
+  def initialize(app, &block)
+    @app = app
+    @absolute_proc = block || DEFAULT_ABSOLUTE_PROC
+  end
+
+  # Call the next middleware with the environment.  If the request was a
+  # redirect (response status 301, 302, or 303), and the location header does
+  # not start with an http or https url scheme, call the block provided by new
+  # 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].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)
+        "#{absolute}#{loc}"
+      else
+        "#{absolute}#{File.dirname(Rack::Utils.unescape(env['PATH_INFO']))}/#{loc}"
+      end
+    end
+    res
+  end
+end

data/lib/rack/contrib/response_cache.rb

@@ -0,0 +1,59 @@
+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.
+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
+  # include '..'.  If the Content-Type of the response is text/(html|css|xml),
+  # return a path with the appropriate extension (.html, .css, or .xml).
+  # If the path ends with a / and the Content-Type is text/html, change the basename
+  # 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'])
+      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'
+      path
+    end
+  end
+
+  # Initialize a new ReponseCache object with the given arguments.  Arguments:
+  # * app : The next middleware in the chain.  This is always called.
+  # * cache : The place to cache responses.  If a string is provided, a disk
+  #   cache is used, and all cached files will use this directory as the root directory.
+  #   If anything other than a string is provided, it should respond to []=, which will
+  #   be called with a path string and a body value (the 3rd element of the response).
+  # * &block : If provided, it is called with the environment and the response from the next middleware.
+  #   It should return nil or false if the path should not be cached, and should return
+  #   the pathname to use as a string if the result should be cached.
+  #   If not provided, the DEFAULT_PATH_PROC is used.
+  def initialize(app, cache, &block)
+    @app = app
+    @cache = cache
+    @path_proc = block || DEFAULT_PATH_PROC
+  end
+
+  # Call the next middleware with the environment.  If the request was successful (response status 200),
+  # was a GET request, and had an empty query string, call the block set up in initialize to get the path.
+  # 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 reponse 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)
+      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)}}
+      else
+        @cache[path] = res[2]
+      end
+    end
+    res
+  end
+end