rack 0.2.0 → 0.3.0

data/lib/rack/builder.rb

@@ -22,8 +22,12 @@ module Rack
       instance_eval(&block)
     end
 
-    def use(middleware, *args)
-      @ins << lambda { |app| middleware.new(app, *args) }
+    def use(middleware, *args, &block)
+      @ins << if block_given?
+        lambda { |app| middleware.new(app, *args, &block) }
+      else
+        lambda { |app| middleware.new(app, *args) }
+      end
     end
 
     def run(app)
@@ -41,8 +45,8 @@ module Rack
 
     def to_app
       @ins[-1] = Rack::URLMap.new(@ins.last)  if Hash === @ins.last
-      inner_app = @ins.pop
-      @ins.reverse.inject(inner_app) { |a, e| e.call(a) }
+      inner_app = @ins.last
+      @ins[0...-1].reverse.inject(inner_app) { |a, e| e.call(a) }
     end
 
     def call(env)

data/lib/rack/file.rb

@@ -24,11 +24,12 @@ module Rack
         return [403, {"Content-Type" => "text/plain"}, ["Forbidden\n"]]
       end
 
-      @path = F.join(@root, env["PATH_INFO"])
+      @path = F.join(@root, Utils.unescape(env["PATH_INFO"]))
       ext = F.extname(@path)[1..-1]
 
       if F.file?(@path) && F.readable?(@path)
         [200, {
+           "Last-Modified"  => F.mtime(@path).rfc822,
            "Content-Type"   => MIME_TYPES[ext] || "text/plain",
            "Content-Length" => F.size(@path).to_s
          }, self]
@@ -72,6 +73,7 @@ module Rack
       "jpe"   => "image/jpeg",
       "jpeg"  => "image/jpeg",
       "jpg"   => "image/jpeg",
+      "js"    => "text/javascript",
       "lha"   => "application/octet-stream",
       "lzh"   => "application/octet-stream",
       "mov"   => "video/quicktime",

data/lib/rack/handler/fastcgi.rb

@@ -3,7 +3,9 @@ require 'fcgi'
 module Rack
   module Handler
     class FastCGI
-      def self.run(app, options=nil)
+      def self.run(app, options={})
+        file = options[:File] and STDIN.reopen(UNIXServer.new(file))
+        port = options[:Port] and STDIN.reopen(TCPServer.new(port))
         FCGI.each { |request|
           serve request, app
         }

data/lib/rack/handler/lsws.rb

@@ -0,0 +1,52 @@
+require 'lsapi'
+#require 'cgi'
+module Rack
+  module Handler
+    class LSWS
+      def self.run(app, options=nil)
+        while LSAPI.accept != nil
+          serve app
+        end
+      end
+      def self.serve(app)
+        env = ENV.to_hash
+        env.delete "HTTP_CONTENT_LENGTH"
+        env["SCRIPT_NAME"] = "" if env["SCRIPT_NAME"] == "/"
+        env.update({"rack.version" => [0,1],
+                     "rack.input" => STDIN,
+                     "rack.errors" => STDERR,
+                     "rack.multithread" => false,
+                     "rack.multiprocess" => true,
+                     "rack.run_once" => false,
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
+                   })
+        env["QUERY_STRING"] ||= ""
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["REQUEST_PATH"] ||= "/"
+        status, headers, body = app.call(env)
+        begin
+          send_headers status, headers
+          send_body body
+        ensure
+          body.close if body.respond_to? :close
+        end
+      end
+      def self.send_headers(status, headers)
+        print "Status: #{status}\r\n"
+        headers.each { |k, vs|
+          vs.each { |v|
+            print "#{k}: #{v}\r\n"
+          }
+        }
+        print "\r\n"
+        STDOUT.flush
+      end
+      def self.send_body(body)
+        body.each { |part|
+          print part
+          STDOUT.flush
+        }
+      end
+    end
+  end
+end

data/lib/rack/handler/scgi.rb

@@ -0,0 +1,57 @@
+require 'scgi'
+require 'stringio'
+
+module Rack
+  module Handler
+    class SCGI < ::SCGI::Processor
+      attr_accessor :app
+      
+      def self.run(app, options=nil)
+        new(options.merge(:app=>app,
+                          :host=>options[:Host],
+                          :port=>options[:Port],
+                          :socket=>options[:Socket])).listen
+      end
+      
+      def initialize(settings = {})
+        @app = settings[:app]
+        @log = Object.new
+        def @log.info(*args); end
+        def @log.error(*args); end
+        super(settings)
+      end
+        
+      def process_request(request, input_body, socket)
+        env = {}.replace(request)
+        env.delete "HTTP_CONTENT_TYPE"
+        env.delete "HTTP_CONTENT_LENGTH"
+        env["REQUEST_PATH"], env["QUERY_STRING"] = env["REQUEST_URI"].split('?', 2)
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["PATH_INFO"] = env["REQUEST_PATH"]
+        env["QUERY_STRING"] ||= ""
+        env["SCRIPT_NAME"] = ""
+        env.update({"rack.version" => [0,1],
+                     "rack.input" => StringIO.new(input_body),
+                     "rack.errors" => STDERR,
+
+                     "rack.multithread" => true,
+                     "rack.multiprocess" => true,
+                     "rack.run_once" => false,
+
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
+                   })
+        status, headers, body = app.call(env)
+        begin
+          socket.write("Status: #{status}\r\n")
+          headers.each do |k, vs|
+            vs.each {|v| socket.write("#{k}: #{v}\r\n")}
+          end
+          socket.write("\r\n")
+          body.each {|s| socket.write(s)}
+        ensure
+          body.close if body.respond_to? :close
+        end
+      end
+    end
+  end
+end

data/lib/rack/lint.rb

@@ -158,7 +158,7 @@ module Rack
       ## * There must be a valid error stream in <tt>rack.errors</tt>.
       check_error env["rack.errors"]
 
-      ## * The <tt>REQUEST_METHOD</tt> must be one of +GET+, +POST+,
+      ## * The <tt>REQUEST_METHOD</tt> must be one of +GET+, +POST+, +PUT+,
       ##   +DELETE+, +HEAD+, +OPTIONS+, +TRACE+.
       assert("REQUEST_METHOD unknown: #{env["REQUEST_METHOD"]}") {
         %w[GET POST PUT DELETE
@@ -226,11 +226,11 @@ module Rack
       ##   and return a string, or +nil+ on EOF.
       def read(*args)
         assert("rack.input#read called with too many arguments") {
-          args.size < 1
+          args.size <= 1
         }
         if args.size == 1
           assert("rack.input#read called with non-integer argument") {
-            args.first.instance_of? Integer
+            args.first.kind_of? Integer
           }
         end
         v = @input.read(*args)
@@ -343,11 +343,11 @@ module Rack
     def check_content_type(status, headers)
       headers.each { |key, value|
         ## There must be a <tt>Content-Type</tt>, except when the
-        ## +Status+ is 201, 204, 304, in which case there must be none
+        ## +Status+ is 204 or 304, in which case there must be none
         ## given.
         if key.downcase == "content-type"
           assert("Content-Type header found in #{status} response, not allowed"){
-            not [201, 204, 304].include? status.to_i
+            not [204, 304].include? status.to_i
           }
           return
         end

data/lib/rack/request.rb

@@ -101,9 +101,16 @@ module Rack
         @env["rack.request.cookie_hash"]
       else
         @env["rack.request.cookie_string"] = @env["HTTP_COOKIE"]
-        # XXX sure?
+        # According to RFC 2109:
+        #   If multiple cookies satisfy the criteria above, they are ordered in
+        #   the Cookie header such that those with more specific Path attributes
+        #   precede those with less specific.  Ordering with respect to other
+        #   attributes (e.g., Domain) is unspecified.
         @env["rack.request.cookie_hash"] =
-          Utils.parse_query(@env["rack.request.cookie_string"], ';,')
+          Utils.parse_query(@env["rack.request.cookie_string"], ';,').inject({}) {|h,(k,v)|
+            h[k] = Array === v ? v.first : v
+            h
+          }
       end
     end
 

data/lib/rack/response.rb

@@ -55,8 +55,10 @@ module Rack
       when Hash
         domain  = "; domain="  + value[:domain]    if value[:domain]
         path    = "; path="    + value[:path]      if value[:path]
+        # According to RFC 2109, we need dashes here.
+        # N.B.: cgi.rb uses spaces...
         expires = "; expires=" + value[:expires].clone.gmtime.
-          strftime("%a, %d %b %Y %H:%M:%S GMT")    if value[:expires]
+          strftime("%a, %d-%b-%Y %H:%M:%S GMT")    if value[:expires]
         value = value[:value]
       end
       value = [value]  unless Array === value
@@ -76,7 +78,7 @@ module Rack
 
     def delete_cookie(key, value={})
       unless Array === self["Set-Cookie"]
-        self["Set-Cookie"] = [self["Set-Cookie"]]
+        self["Set-Cookie"] = [self["Set-Cookie"]].compact
       end
 
       self["Set-Cookie"].reject! { |cookie|
@@ -92,7 +94,7 @@ module Rack
     def finish(&block)
       @block = block
 
-      if [201, 204, 304].include?(status.to_i)
+      if [204, 304].include?(status.to_i)
         header.delete "Content-Type"
         [status.to_i, header.to_hash, []]
       else
@@ -112,6 +114,10 @@ module Rack
       str
     end
 
+    def close
+      body.close if body.respond_to?(:close)
+    end
+
     def empty?
       @block == nil && @body.empty?
     end

data/lib/rack/session/cookie.rb

@@ -1,5 +1,3 @@
-require 'base64'
-
 module Rack
 
   module Session
@@ -40,7 +38,7 @@ module Rack
         session_data = request.cookies[@key]
 
         begin
-          session_data = Base64.decode64(session_data)
+          session_data = session_data.unpack("m*").first
           session_data = Marshal.load(session_data)
           env["rack.session"] = session_data
         rescue
@@ -52,7 +50,7 @@ module Rack
 
       def commit_session(env, status, headers, body)
         session_data = Marshal.dump(env["rack.session"])
-        session_data = Base64.encode64(session_data)
+        session_data = [session_data].pack("m*")
 
         if session_data.size > (4096 - @key.size)
           env["rack.errors"].puts("Warning! Rack::Session::Cookie data size exceeds 4K. Content dropped.")

data/lib/rack/session/pool.rb

@@ -0,0 +1,82 @@
+# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
+
+module Rack
+  module Session
+    # Rack::Session::Pool provides simple cookie based session management.
+    # Session data is stored in a hash held by @pool. The corresponding
+    # session key sent to the client.
+    # The pool is unmonitored and unregulated, which means that over
+    # prolonged use the session pool will be very large.
+    #
+    # Example:
+    #
+    #     use Rack::Session::Pool, :key => 'rack.session',
+    #                              :domain => 'foo.com',
+    #                              :path => '/',
+    #                              :expire_after => 2592000
+    #
+    #     All parameters are optional.
+
+    class Pool
+      attr_reader :pool, :key
+
+      def initialize(app, options={})
+        @app = app
+        @key = options[:key] || "rack.session"
+        @default_options = {:domain => nil,
+          :path => "/",
+          :expire_after => nil}.merge(options)
+        @pool = Hash.new
+        @default_context = context app, &nil
+      end
+
+
+      def call(env)
+        @default_context.call(env)
+      end
+
+      def context(app, &block)
+        Rack::Utils::Context.new self, app do |env|
+          load_session env
+          block[env] if block
+          response = app.call(env)
+          commit_session env, response
+          response
+        end
+      end
+
+      private
+
+      def load_session(env)
+        sess_id = env.fetch('HTTP_COOKIE','')[/#{@key}=([^,;]+)/,1]
+        begin
+          sess_id = Array.new(8){rand(16).to_s(16)}*''
+        end while @pool.key? sess_id if sess_id.nil? or !@pool.key? sess_id
+
+        session = @pool.fetch sess_id, {}
+        session.instance_variable_set '@dat', [sess_id, Time.now]
+
+        @pool.store sess_id, env['rack.session'] = session
+        env["rack.session.options"] = @default_options.dup
+      end
+
+      def commit_session(env, response)
+        session = env['rack.session']
+        options = env['rack.session.options']
+        sdat    = session.instance_variable_get '@dat'
+
+        cookie = Utils.escape(@key)+'='+Utils.escape(sdat[0])
+        cookie<< "; domain=#{options[:domain]}" if options[:domain]
+        cookie<< "; path=#{options[:path]}" if options[:path]
+        cookie<< "; expires=#{sdat[1]+options[:expires_after]}" if options[:expires_after]
+
+        case a = (h = response[1])['Set-Cookie']
+        when Array then  a << cookie
+        when String then h['Set-Cookie'] = [a, cookie]
+        when nil then    h['Set-Cookie'] = cookie
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/showexceptions.rb

@@ -217,7 +217,7 @@ TEMPLATE = <<'HTML'
               <% if frame.pre_context %>
               <ol start="<%=h frame.pre_context_lineno+1 %>" class="pre-context" id="pre<%=h frame.object_id %>">
                 <% frame.pre_context.each { |line| %>
-                <li onclick="toggle('pre<%=h frame.object_id %>', 'post<%=h frame.object_id %>"><%=h line %></li>
+                <li onclick="toggle('pre<%=h frame.object_id %>', 'post<%=h frame.object_id %>')"><%=h line %></li>
                 <% } %>
               </ol>
               <% end %>

data/lib/rack/urlmap.rb

@@ -28,15 +28,13 @@ module Rack
 
     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|
-        if (env["HTTP_HOST"] == host ||
-            env["SERVER_NAME"] == host ||
-            (host == nil && (env["HTTP_HOST"] == env["SERVER_NAME"] ||
-                             env["HTTP_HOST"] ==
-                             "#{env["SERVER_NAME"]}:#{env["SERVER_PORT"]}"))) &&
-           location == path[0, location.size] && (path[location.size] == nil ||
-                                                  path[location.size] == ?/)
-          env["SCRIPT_NAME"] = location.dup
+        if (hHost == host || sName == host \
+          || (host.nil? && (hHost == sName || hHost == sName+':'+sPort))) \
+          and location == path[0, location.size] \
+          and (path[location.size] == nil || path[location.size] == ?/)
+          env["SCRIPT_NAME"] += location.dup
           env["PATH_INFO"] = path[location.size..-1]
           env["PATH_INFO"].gsub!(/\/\z/, '')
           env["PATH_INFO"] = "/"  if env["PATH_INFO"].empty?

data/lib/rack/utils.rb

@@ -58,6 +58,27 @@ module Rack
     end
     module_function :escape_html
 
+    class Context < Proc
+      def initialize app_f=nil, app_r=nil
+        @for, @app = app_f, app_r
+      end
+      alias_method :old_inspect, :inspect
+      def inspect
+        "#{old_inspect} ==> #{@for.inspect} ==> #{@app.inspect}"
+      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={})

data/test/cgi/lighttpd.conf

@@ -5,7 +5,7 @@ server.port = 9203
 
 server.event-handler = "freebsd-kqueue"
 
-cgi.assign = ("/test" => "/usr/local/bin/ruby",
+cgi.assign = ("/test" => "/usr/bin/ruby",
 #              ".ru" => ""
              )
 

data/test/cgi/test.ru

@@ -1,4 +1,4 @@
-#!/usr/local/bin/ruby ../../bin/rackup
+#!/usr/bin/env ruby ../../bin/rackup
 #\ -E deployment -I ~/projects/rack/lib
 # -*- ruby -*-