RubyGems - kastner-rack - Versions diffs - 0.3.171 - Mend

kastner-rack 0.3.171

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (94) hide show

data/AUTHORS +8 -0
data/COPYING +18 -0
data/KNOWN-ISSUES +18 -0
data/README +273 -0
data/Rakefile +185 -0
data/bin/rackup +172 -0
data/contrib/rack_logo.svg +111 -0
data/example/lobster.ru +4 -0
data/example/protectedlobster.rb +14 -0
data/example/protectedlobster.ru +8 -0
data/lib/rack.rb +85 -0
data/lib/rack/adapter/camping.rb +22 -0
data/lib/rack/auth/abstract/handler.rb +28 -0
data/lib/rack/auth/abstract/request.rb +37 -0
data/lib/rack/auth/basic.rb +58 -0
data/lib/rack/auth/digest/md5.rb +124 -0
data/lib/rack/auth/digest/nonce.rb +51 -0
data/lib/rack/auth/digest/params.rb +55 -0
data/lib/rack/auth/digest/request.rb +40 -0
data/lib/rack/auth/openid.rb +437 -0
data/lib/rack/builder.rb +67 -0
data/lib/rack/cascade.rb +36 -0
data/lib/rack/commonlogger.rb +61 -0
data/lib/rack/conditionalget.rb +42 -0
data/lib/rack/deflater.rb +63 -0
data/lib/rack/directory.rb +149 -0
data/lib/rack/file.rb +84 -0
data/lib/rack/handler.rb +46 -0
data/lib/rack/handler/cgi.rb +57 -0
data/lib/rack/handler/evented_mongrel.rb +8 -0
data/lib/rack/handler/fastcgi.rb +86 -0
data/lib/rack/handler/lsws.rb +52 -0
data/lib/rack/handler/mongrel.rb +78 -0
data/lib/rack/handler/scgi.rb +57 -0
data/lib/rack/handler/swiftiplied_mongrel.rb +8 -0
data/lib/rack/handler/webrick.rb +61 -0
data/lib/rack/head.rb +19 -0
data/lib/rack/lint.rb +463 -0
data/lib/rack/lobster.rb +65 -0
data/lib/rack/methodoverride.rb +21 -0
data/lib/rack/mime.rb +204 -0
data/lib/rack/mock.rb +160 -0
data/lib/rack/recursive.rb +57 -0
data/lib/rack/reloader.rb +64 -0
data/lib/rack/request.rb +217 -0
data/lib/rack/response.rb +171 -0
data/lib/rack/session/abstract/id.rb +140 -0
data/lib/rack/session/cookie.rb +89 -0
data/lib/rack/session/memcache.rb +97 -0
data/lib/rack/session/pool.rb +73 -0
data/lib/rack/showexceptions.rb +348 -0
data/lib/rack/showstatus.rb +105 -0
data/lib/rack/static.rb +38 -0
data/lib/rack/urlmap.rb +48 -0
data/lib/rack/utils.rb +318 -0
data/rack.gemspec +31 -0
data/test/cgi/lighttpd.conf +20 -0
data/test/cgi/test +9 -0
data/test/cgi/test.fcgi +8 -0
data/test/cgi/test.ru +7 -0
data/test/spec_rack_auth_basic.rb +69 -0
data/test/spec_rack_auth_digest.rb +169 -0
data/test/spec_rack_auth_openid.rb +137 -0
data/test/spec_rack_builder.rb +84 -0
data/test/spec_rack_camping.rb +51 -0
data/test/spec_rack_cascade.rb +50 -0
data/test/spec_rack_cgi.rb +89 -0
data/test/spec_rack_commonlogger.rb +32 -0
data/test/spec_rack_conditionalget.rb +41 -0
data/test/spec_rack_deflater.rb +70 -0
data/test/spec_rack_directory.rb +56 -0
data/test/spec_rack_fastcgi.rb +89 -0
data/test/spec_rack_file.rb +57 -0
data/test/spec_rack_handler.rb +24 -0
data/test/spec_rack_head.rb +30 -0
data/test/spec_rack_lint.rb +371 -0
data/test/spec_rack_lobster.rb +45 -0
data/test/spec_rack_methodoverride.rb +31 -0
data/test/spec_rack_mock.rb +152 -0
data/test/spec_rack_mongrel.rb +170 -0
data/test/spec_rack_recursive.rb +77 -0
data/test/spec_rack_request.rb +426 -0
data/test/spec_rack_response.rb +173 -0
data/test/spec_rack_session_cookie.rb +78 -0
data/test/spec_rack_session_memcache.rb +132 -0
data/test/spec_rack_session_pool.rb +84 -0
data/test/spec_rack_showexceptions.rb +21 -0
data/test/spec_rack_showstatus.rb +72 -0
data/test/spec_rack_static.rb +37 -0
data/test/spec_rack_urlmap.rb +175 -0
data/test/spec_rack_utils.rb +174 -0
data/test/spec_rack_webrick.rb +123 -0
data/test/testrequest.rb +45 -0
metadata +177 -0

data/lib/rack/showstatus.rb ADDED Viewed

@@ -0,0 +1,105 @@
+require 'erb'
+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.
+  #
+  # Additional details can be put into <tt>rack.showstatus.detail</tt>
+  # and will be shown as HTML.  If such details exist, the error page
+  # is always rendered, even if the reply was not empty.
+  class ShowStatus
+    def initialize(app)
+      @app = app
+      @template = ERB.new(TEMPLATE)
+    end
+    def call(env)
+      status, headers, body = @app.call(env)
+      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)
+        message = Rack::Utils::HTTP_STATUS_CODES[status.to_i] || status.to_s
+        detail = env["rack.showstatus.detail"] || message
+        body = @template.result(binding)
+        size = body.respond_to?(:bytesize) ? body.bytesize : body.size
+        [status, headers.merge("Content-Type" => "text/html", "Content-Length" => size.to_s), [body]]
+      else
+        [status, headers, body]
+      end
+    end
+    def h(obj)                  # :nodoc:
+      case obj
+      when String
+        Utils.escape_html(obj)
+      else
+        Utils.escape_html(obj.inspect)
+      end
+    end
+    # :stopdoc:
+# adapted from Django <djangoproject.com>
+# Copyright (c) 2005, the Lawrence Journal-World
+# Used under the modified BSD license:
+# http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5
+TEMPLATE = <<'HTML'
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <title><%=h message %> at <%=h req.script_name + req.path_info %></title>
+  <meta name="robots" content="NONE,NOARCHIVE" />
+  <style type="text/css">
+    html * { padding:0; margin:0; }
+    body * { padding:10px 20px; }
+    body * * { padding:0; }
+    body { font:small sans-serif; background:#eee; }
+    body>div { border-bottom:1px solid #ddd; }
+    h1 { font-weight:normal; margin-bottom:.4em; }
+    h1 span { font-size:60%; color:#666; font-weight:normal; }
+    table { border:none; border-collapse: collapse; width:100%; }
+    td, th { vertical-align:top; padding:2px 3px; }
+    th { width:12em; text-align:right; color:#666; padding-right:.5em; }
+    #info { background:#f6f6f6; }
+    #info ol { margin: 0.5em 4em; }
+    #info ol li { font-family: monospace; }
+    #summary { background: #ffc; }
+    #explanation { background:#eee; border-bottom: 0px none; }
+  </style>
+</head>
+<body>
+  <div id="summary">
+    <h1><%=h message %> <span>(<%= status.to_i %>)</span></h1>
+    <table class="meta">
+      <tr>
+        <th>Request Method:</th>
+        <td><%=h req.request_method %></td>
+      </tr>
+      <tr>
+        <th>Request URL:</th>
+      <td><%=h req.url %></td>
+      </tr>
+    </table>
+  </div>
+  <div id="info">
+    <p><%= detail %></p>
+  </div>
+  <div id="explanation">
+    <p>
+    You're seeing this error because you use <code>Rack::ShowStatus</code>.
+    </p>
+  </div>
+</body>
+</html>
+HTML
+    # :startdoc:
+  end
+end

data/lib/rack/static.rb ADDED Viewed

@@ -0,0 +1,38 @@
+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.
+  #
+  # Examples:
+  #     use Rack::Static, :urls => ["/media"]
+  #     will serve all requests beginning with /media from the "media" folder
+  #     located in the current directory (ie media/*).
+  #
+  #     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/*)
+  class Static
+    def initialize(app, options={})
+      @app = app
+      @urls = options[:urls] || ["/favicon.ico"]
+      root = options[:root] || Dir.pwd
+      @file_server = Rack::File.new(root)
+    end
+    def call(env)
+      path = env["PATH_INFO"]
+      can_serve = @urls.any? { |url| path.index(url) == 0 }
+      if can_serve
+        @file_server.call(env)
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rack/urlmap.rb ADDED Viewed

@@ -0,0 +1,48 @@
+module Rack
+  # Rack::URLMap takes a hash mapping urls or paths to apps, and
+  # dispatches accordingly.  Support for HTTP/1.1 host names exists if
+  # the URLs start with <tt>http://</tt> or <tt>https://</tt>.
+  #
+  # URLMap modifies the SCRIPT_NAME and PATH_INFO such that the part
+  # relevant for dispatch is in the SCRIPT_NAME, and the rest in the
+  # PATH_INFO.  This should be taken care of when you need to
+  # reconstruct the URL in order to create links.
+  #
+  # URLMap dispatches in such a way that the longest paths are tried
+  # first, since they are most specific.
+  class URLMap
+    def initialize(map)
+      @mapping = map.map { |location, app|
+        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('/')
+        [host, location, app]
+      }.sort_by { |(h, l, a)| -l.size }  # Longest path first
+    end
+    def call(env)
+      path = env["PATH_INFO"].to_s.squeeze("/")
+      hHost, sName, sPort = env.values_at('HTTP_HOST','SERVER_NAME','SERVER_PORT')
+      @mapping.each { |host, location, app|
+        next unless (hHost == host || sName == host \
+          || (host.nil? && (hHost == sName || hHost == sName+':'+sPort)))
+        next unless location == path[0, location.size]
+        next unless path[location.size] == nil || path[location.size] == ?/
+        env["SCRIPT_NAME"] += location
+        env["PATH_INFO"]    = path[location.size..-1]
+        return app.call(env)
+      }
+      [404, {"Content-Type" => "text/plain"}, ["Not Found: #{path}"]]
+    end
+  end
+end

data/lib/rack/utils.rb ADDED Viewed

@@ -0,0 +1,318 @@
+require 'tempfile'
+module Rack
+  # Rack::Utils contains a grab-bag of useful methods for writing web
+  # applications adopted from all kinds of Ruby libraries.
+  module Utils
+    # Performs URI escaping so that you can construct proper
+    # query strings faster.  Use this rather than the cgi.rb
+    # version since it's faster.  (Stolen from Camping).
+    def escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+        '%'+$1.unpack('H2'*$1.size).join('%').upcase
+      }.tr(' ', '+')
+    end
+    module_function :escape
+    # Unescapes a URI escaped string. (Stolen from Camping).
+    def unescape(s)
+      s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+        [$1.delete('%')].pack('H*')
+      }
+    end
+    module_function :unescape
+    # Stolen from Mongrel, with some small modifications:
+    # Parses a query string by breaking it up at the '&'
+    # and ';' characters.  You can also use this to parse
+    # cookies by changing the characters used in the second
+    # parameter (which defaults to '&;').
+    def parse_query(qs, d = '&;')
+      params = {}
+      (qs || '').split(/[#{d}] */n).each do |p|
+        k, v = unescape(p).split('=', 2)
+        if cur = params[k]
+          if cur.class == Array
+            params[k] << v
+          else
+            params[k] = [cur, v]
+          end
+        else
+          params[k] = v
+        end
+      end
+      return params
+    end
+    module_function :parse_query
+    def build_query(params)
+      params.map { |k, v|
+        if v.class == Array
+          build_query(v.map { |x| [k, x] })
+        else
+          escape(k) + "=" + escape(v)
+        end
+      }.join("&")
+    end
+    module_function :build_query
+    # Escape ampersands, brackets and quotes to their HTML/XML entities.
+    def escape_html(string)
+      string.to_s.gsub("&", "&amp;").
+        gsub("<", "&lt;").
+        gsub(">", "&gt;").
+        gsub("'", "&#39;").
+        gsub('"', "&quot;")
+    end
+    module_function :escape_html
+    def select_best_encoding(available_encodings, accept_encoding)
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+      expanded_accept_encoding =
+        accept_encoding.map { |m, q|
+          if m == "*"
+            (available_encodings - accept_encoding.map { |m2, _| m2 }).map { |m2| [m2, q] }
+          else
+            [[m, q]]
+          end
+        }.inject([]) { |mem, list|
+          mem + list
+        }
+      encoding_candidates = expanded_accept_encoding.sort_by { |_, q| -q }.map { |m, _| m }
+      unless encoding_candidates.include?("identity")
+        encoding_candidates.push("identity")
+      end
+      expanded_accept_encoding.find_all { |m, q|
+        q == 0.0
+      }.each { |m, _|
+        encoding_candidates.delete(m)
+      }
+      return (encoding_candidates & available_encodings)[0]
+    end
+    module_function :select_best_encoding
+    # The recommended manner in which to implement a contexting application
+    # is to define a method #context in which a new Context is instantiated.
+    #
+    # As a Context is a glorified block, it is highly recommended that you
+    # define the contextual block within the application's operational scope.
+    # This would typically the application as you're place into Rack's stack.
+    #
+    #   class MyObject
+    #     ...
+    #     def context app
+    #       Rack::Utils::Context.new app do |env|
+    #         do_stuff
+    #         response = app.call(env)
+    #         do_more_stuff
+    #       end
+    #     end
+    #     ...
+    #   end
+    #
+    # mobj = MyObject.new
+    # app = mobj.context other_app
+    # Rack::Handler::Mongrel.new app
+    class Context < Proc
+      alias_method :old_inspect, :inspect
+      attr_reader :for, :app
+      def initialize app_f, app_r
+        raise 'running context not provided' unless app_f
+        raise 'running context does not respond to #context' unless app_f.respond_to? :context
+        raise 'application context not provided' unless app_r
+        raise 'application context does not respond to #call' unless app_r.respond_to? :call
+        @for = app_f
+        @app = app_r
+      end
+      def inspect
+        "#{old_inspect} ==> #{@for.inspect} ==> #{@app.inspect}"
+      end
+      def context app_r
+        raise 'new application context not provided' unless app_r
+        raise 'new application context does not respond to #call' unless app_r.respond_to? :call
+        @for.context app_r
+      end
+      def pretty_print pp
+        pp.text old_inspect
+        pp.nest 1 do
+          pp.breakable
+          pp.text '=for> '
+          pp.pp @for
+          pp.breakable
+          pp.text '=app> '
+          pp.pp @app
+        end
+      end
+    end
+    # A case-normalizing Hash, adjusting on [] and []=.
+    class HeaderHash < Hash
+      def initialize(hash={})
+        hash.each { |k, v| self[k] = v }
+      end
+      def to_hash
+        {}.replace(self)
+      end
+      def [](k)
+        super capitalize(k)
+      end
+      def []=(k, v)
+        super capitalize(k), v
+      end
+      def capitalize(k)
+        k.to_s.downcase.gsub(/^.|[-_\s]./) { |x| x.upcase }
+      end
+    end
+    # Every standard HTTP code mapped to the appropriate message.
+    # Stolen from Mongrel.
+    HTTP_STATUS_CODES = {
+      100  => 'Continue',
+      101  => 'Switching Protocols',
+      200  => 'OK',
+      201  => 'Created',
+      202  => 'Accepted',
+      203  => 'Non-Authoritative Information',
+      204  => 'No Content',
+      205  => 'Reset Content',
+      206  => 'Partial Content',
+      300  => 'Multiple Choices',
+      301  => 'Moved Permanently',
+      302  => 'Moved Temporarily',
+      303  => 'See Other',
+      304  => 'Not Modified',
+      305  => 'Use Proxy',
+      400  => 'Bad Request',
+      401  => 'Unauthorized',
+      402  => 'Payment Required',
+      403  => 'Forbidden',
+      404  => 'Not Found',
+      405  => 'Method Not Allowed',
+      406  => 'Not Acceptable',
+      407  => 'Proxy Authentication Required',
+      408  => 'Request Time-out',
+      409  => 'Conflict',
+      410  => 'Gone',
+      411  => 'Length Required',
+      412  => 'Precondition Failed',
+      413  => 'Request Entity Too Large',
+      414  => 'Request-URI Too Large',
+      415  => 'Unsupported Media Type',
+      500  => 'Internal Server Error',
+      501  => 'Not Implemented',
+      502  => 'Bad Gateway',
+      503  => 'Service Unavailable',
+      504  => 'Gateway Time-out',
+      505  => 'HTTP Version not supported'
+    }
+    # A multipart form data parser, adapted from IOWA.
+    #
+    # Usually, Rack::Request#POST takes care of calling this.
+    module Multipart
+      EOL = "\r\n"
+      def self.parse_multipart(env)
+        unless env['CONTENT_TYPE'] =~
+            %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n
+          nil
+        else
+          boundary = "--#{$1}"
+          params = {}
+          buf = ""
+          content_length = env['CONTENT_LENGTH'].to_i
+          input = env['rack.input']
+          boundary_size = boundary.size + EOL.size
+          bufsize = 16384
+          content_length -= boundary_size
+          status = input.read(boundary_size)
+          raise EOFError, "bad content body"  unless status == boundary + EOL
+          rx = /(?:#{EOL})?#{Regexp.quote boundary}(#{EOL}|--)/
+          loop {
+            head = nil
+            body = ''
+            filename = content_type = name = nil
+            until head && buf =~ rx
+              if !head && i = buf.index("\r\n\r\n")
+                head = buf.slice!(0, i+2) # First \r\n
+                buf.slice!(0, 2)          # Second \r\n
+                filename = head[/Content-Disposition:.* filename="?([^\";]*)"?/ni, 1]
+                content_type = head[/Content-Type: (.*)\r\n/ni, 1]
+                name = head[/Content-Disposition:.* name="?([^\";]*)"?/ni, 1]
+                if filename
+                  body = Tempfile.new("RackMultipart")
+                  body.binmode  if body.respond_to?(:binmode)
+                end
+                next
+              end
+              # Save the read body part.
+              if head && (boundary_size+4 < buf.size)
+                body << buf.slice!(0, buf.size - (boundary_size+4))
+              end
+              c = input.read(bufsize < content_length ? bufsize : content_length)
+              raise EOFError, "bad content body"  if c.nil? || c.empty?
+              buf << c
+              content_length -= c.size
+            end
+            # Save the rest.
+            if i = buf.index(rx)
+              body << buf.slice!(0, i)
+              buf.slice!(0, boundary_size+2)
+              content_length = -1  if $1 == "--"
+            end
+            if filename
+              body.rewind
+              data = {:filename => filename, :type => content_type,
+                      :name => name, :tempfile => body, :head => head}
+            else
+              data = body
+            end
+            if name
+              if name =~ /\[\]\z/
+                params[name] ||= []
+                params[name] << data
+              else
+                params[name] = data
+              end
+            end
+            break  if buf.empty? || content_length == -1
+          }
+          params
+        end
+      end
+    end
+  end
+end