rack 0.1.0 → 0.2.0

data/lib/rack/recursive.rb

@@ -28,7 +28,7 @@ module Rack
   # include data from other applications (by using
   # <tt>rack['rack.recursive.include'][...]</tt> or raise a
   # ForwardRequest to redirect internally.
-  
+
   class Recursive
     def initialize(app)
       @app = app

data/lib/rack/reloader.rb

@@ -6,7 +6,7 @@ module Rack
   # rack.errors.
   #
   # It is recommended you use ShowExceptions to catch SyntaxErrors etc.
-  
+
   class Reloader
     def initialize(app, secs=10)
       @app = app

data/lib/rack/request.rb

@@ -8,11 +8,11 @@ module Rack
   #   req = Rack::Request.new(env)
   #   req.post?
   #   req.params["data"]
-  
+
   class Request
     # The environment of the request.
     attr_reader :env
-    
+
     def initialize(env)
       @env = env
     end
@@ -59,7 +59,7 @@ module Rack
       else
         @env["rack.request.form_input"] = @env["rack.input"]
         unless @env["rack.request.form_hash"] =
-            Utils::Multipart.parse_multipart(env) 
+            Utils::Multipart.parse_multipart(env)
           @env["rack.request.form_vars"] = @env["rack.input"].read
           @env["rack.request.form_hash"] = Utils.parse_query(@env["rack.request.form_vars"])
         end
@@ -72,6 +72,28 @@ module Rack
       self.GET.update(self.POST)
     end
 
+    # shortcut for request.params[key]
+    def [](key)
+      params[key.to_s]
+    end
+
+    # shortcut for request.params[key] = value
+    def []=(key, value)
+      params[key.to_s] = value
+    end
+
+    # like Hash#values_at
+    def values_at(*keys)
+      keys.map{|key| params[key] }
+    end
+
+    # the referer of the client or '/'
+    def referer
+      @env['HTTP_REFERER'] || '/'
+    end
+    alias referrer referer
+
+
     def cookies
       return {}  unless @env["HTTP_COOKIE"]
 
@@ -99,14 +121,15 @@ module Rack
         url << ":#{port}"
       end
 
-      url << script_name
-      url << path_info
-
-      unless query_string.empty?
-        url << "?" << query_string
-      end
+      url << fullpath
 
       url
     end
+
+    def fullpath
+      path = script_name + path_info
+      path << "?" << query_string  unless query_string.empty?
+      path
+    end
   end
 end

data/lib/rack/response.rb

@@ -2,18 +2,18 @@ require 'rack/request'
 require 'rack/utils'
 
 module Rack
-  # Rack::Request provides a convenient interface to create a Rack
+  # Rack::Response provides a convenient interface to create a Rack
   # response.
   #
   # It allows setting of headers and cookies, and provides useful
   # defaults (a OK response containing HTML).
   #
-  # You can use Request#write to iteratively generate your response,
-  # but note that this is buffered by Rack::Request until you call
+  # You can use Response#write to iteratively generate your response,
+  # but note that this is buffered by Rack::Response until you call
   # +finish+.  +finish+ however can take a block inside which calls to
   # +write+ are syncronous with the Rack response.
   #
-  # Your application's +call+ should end returning Request#finish.
+  # Your application's +call+ should end returning Response#finish.
 
   class Response
     def initialize(body=[], status=200, header={}, &block)
@@ -22,17 +22,18 @@ module Rack
                                       merge(header))
 
       @writer = lambda { |x| @body << x }
+      @block = nil
 
       @body = []
 
-      if body.kind_of?(String)
-        write body
+      if body.respond_to? :to_str
+        write body.to_str
       elsif body.respond_to?(:each)
         body.each { |part|
           write part.to_s
         }
       else
-        raise TypeError, "String or iterable required"
+        raise TypeError, "stringable or iterable required"
       end
 
       yield self  if block_given?
@@ -107,8 +108,53 @@ module Rack
     end
 
     def write(str)
-      @writer.call str
+      @writer.call str.to_s
       str
     end
+
+    def empty?
+      @block == nil && @body.empty?
+    end
+
+    alias headers header
+
+    module Helpers
+      def invalid?;       @status < 100 || @status >= 600;       end
+
+      def informational?; @status >= 100 && @status < 200;       end
+      def successful?;    @status >= 200 && @status < 300;       end
+      def redirection?;   @status >= 300 && @status < 400;       end
+      def client_error?;  @status >= 400 && @status < 500;       end
+      def server_error?;  @status >= 500 && @status < 600;       end
+
+      def ok?;            @status == 200;                        end
+      def forbidden?;     @status == 403;                        end
+      def not_found?;     @status == 404;                        end
+
+      def redirect?;      [301, 302, 303, 307].include? @status; end
+      def empty?;         [201, 204, 304].include?      @status; end
+
+      # Headers
+      attr_reader :headers, :original_headers
+
+      def include?(header)
+        !!headers[header]
+      end
+
+      def content_type
+        headers["Content-Type"]
+      end
+
+      def content_length
+        cl = headers["Content-Length"]
+        cl ? cl.to_i : cl
+      end
+
+      def location
+        headers["Location"]
+      end
+    end
+
+    include Helpers
   end
 end

data/lib/rack/session/cookie.rb

@@ -0,0 +1,73 @@
+require 'base64'
+
+module Rack
+
+  module Session
+
+    # Rack::Session::Cookie provides simple cookie based session management.
+    # The session is a Ruby Hash stored as base64 encoded marshalled data
+    # set to :key (default: rack.session).
+    #
+    # Example:
+    #
+    #     use Rack::Session::Cookie, :key => 'rack.session',
+    #                                :domain => 'foo.com',
+    #                                :path => '/',
+    #                                :expire_after => 2592000
+    #
+    #     All parameters are optional.
+
+    class Cookie
+
+      def initialize(app, options={})
+        @app = app
+        @key = options[:key] || "rack.session"
+        @default_options = {:domain => nil,
+          :path => "/",
+          :expire_after => nil}.merge(options)
+      end
+
+      def call(env)
+        load_session(env)
+        status, headers, body = @app.call(env)
+        commit_session(env, status, headers, body)
+      end
+
+      private
+
+      def load_session(env)
+        request = Rack::Request.new(env)
+        session_data = request.cookies[@key]
+
+        begin
+          session_data = Base64.decode64(session_data)
+          session_data = Marshal.load(session_data)
+          env["rack.session"] = session_data
+        rescue
+          env["rack.session"] = Hash.new
+        end
+
+        env["rack.session.options"] = @default_options.dup
+      end
+
+      def commit_session(env, status, headers, body)
+        session_data = Marshal.dump(env["rack.session"])
+        session_data = Base64.encode64(session_data)
+
+        if session_data.size > (4096 - @key.size)
+          env["rack.errors"].puts("Warning! Rack::Session::Cookie data size exceeds 4K. Content dropped.")
+          [status, headers, body]
+        else
+          options = env["rack.session.options"]
+          cookie = Hash.new
+          cookie[:value] = session_data
+          cookie[:expires] = Time.now + options[:expire_after] unless options[:expire_after].nil?
+          response = Rack::Response.new(body, status, headers)
+          response.set_cookie(@key, cookie.merge(options))
+          response.to_a
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/showexceptions.rb

@@ -10,7 +10,7 @@ module Rack
   #
   # Be careful when you use this on public-facing sites as it could
   # reveal information helpful to attackers.
-  
+
   class ShowExceptions
     CONTEXT = 7
 
@@ -60,7 +60,7 @@ module Rack
       [@template.result(binding)]
     end
 
-    def h(obj)
+    def h(obj)                  # :nodoc:
       case obj
       when String
         Utils.escape_html(obj)

data/lib/rack/showstatus.rb

@@ -0,0 +1,103 @@
+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)
+
+      # client or server error, or explicit message
+      if status.to_i >= 400 &&
+          (body.empty? rescue false) || 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
+        [status, headers.merge("Content-Type" => "text/html"), [@template.result(binding)]]
+      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

@@ -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

@@ -10,7 +10,7 @@ module Rack
   #
   # 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|

data/lib/rack/utils.rb

@@ -3,7 +3,7 @@ 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
@@ -27,7 +27,7 @@ module Rack
     # 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 '&;'.
+    # parameter (which defaults to '&;').
 
     def parse_query(qs, d = '&;')
       params = {}
@@ -81,10 +81,52 @@ module Rack
       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"