RubyGems - nbudin-castronaut - Versions diffs - 0.7.5 - Mend

nbudin-castronaut 0.7.5

Files changed (968) hide show

data/vendor/rack/lib/rack/showstatus.rb ADDED Viewed

@@ -0,0 +1,106 @@
+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)
+      headers = Utils::HeaderHash.new(headers)
+      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/vendor/rack/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/vendor/rack/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, h.to_s.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/vendor/rack/lib/rack/utils.rb ADDED Viewed

@@ -0,0 +1,347 @@
+require 'set'
+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-insensitive Hash that preserves the original case of a
+    # header when set.
+    class HeaderHash < Hash
+      def initialize(hash={})
+        @names = {}
+        hash.each { |k, v| self[k] = v }
+      end
+      def to_hash
+        {}.replace(self)
+      end
+      def [](k)
+        super @names[k.downcase]
+      end
+      def []=(k, v)
+        delete k
+        @names[k.downcase] = k
+        super k, v
+      end
+      def delete(k)
+        super @names.delete(k.downcase)
+      end
+      def include?(k)
+        @names.has_key? k.downcase
+      end
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
+      end
+      def merge(other)
+        hash = dup
+        hash.merge! other
+      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  => 'Found',
+      303  => 'See Other',
+      304  => 'Not Modified',
+      305  => 'Use Proxy',
+      307  => 'Temporary Redirect',
+      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 Timeout',
+      409  => 'Conflict',
+      410  => 'Gone',
+      411  => 'Length Required',
+      412  => 'Precondition Failed',
+      413  => 'Request Entity Too Large',
+      414  => 'Request-URI Too Large',
+      415  => 'Unsupported Media Type',
+      416  => 'Requested Range Not Satisfiable',
+      417  => 'Expectation Failed',
+      500  => 'Internal Server Error',
+      501  => 'Not Implemented',
+      502  => 'Bad Gateway',
+      503  => 'Service Unavailable',
+      504  => 'Gateway Timeout',
+      505  => 'HTTP Version Not Supported'
+    }
+    # Responses with HTTP status codes that should not have an entity body
+    STATUS_WITH_NO_ENTITY_BODY = Set.new((100..199).to_a << 204 << 304)
+    # 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