rack 0.3.0 → 0.4.0

data/lib/rack/showstatus.rb

@@ -25,7 +25,9 @@ module Rack
         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)]]
+        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

data/lib/rack/urlmap.rb

@@ -20,26 +20,26 @@ module Rack
           host = nil
         end
 
-        location = ""  if location == "/"
+        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
+      }.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|
-        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?
-          return app.call(env)
-        end
+        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

data/lib/rack/utils.rb

@@ -23,7 +23,7 @@ module Rack
     end
     module_function :unescape
 
-    # Stolen from Mongrel:
+    # 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
@@ -31,8 +31,10 @@ module Rack
 
     def parse_query(qs, d = '&;')
       params = {}
-      (qs||'').split(/[#{d}] */n).inject(params) { |h,p|
-        k, v=unescape(p).split('=',2)
+      
+      (qs || '').split(/[#{d}] */n).each do |p|
+        k, v = unescape(p).split('=', 2)
+        
         if cur = params[k]
           if cur.class == Array
             params[k] << v
@@ -42,11 +44,22 @@ module Rack
         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)
@@ -58,14 +71,77 @@ module Rack
     end
     module_function :escape_html
 
-    class Context < Proc
-      def initialize app_f=nil, app_r=nil
-        @for, @app = app_f, app_r
+    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
@@ -187,7 +263,10 @@ module Rack
                 content_type = head[/Content-Type: (.*)\r\n/ni, 1]
                 name = head[/Content-Disposition:.* name="?([^\";]*)"?/ni, 1]
 
-                body = Tempfile.new("RackMultipart")  if filename
+                if filename
+                  body = Tempfile.new("RackMultipart")
+                  body.binmode  if body.respond_to?(:binmode)
+                end
 
                 next
               end

data/test/cgi/lighttpd.conf

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

data/test/cgi/test.fcgi

@@ -1,8 +1,7 @@
 #!/usr/bin/env ruby
 # -*- ruby -*-
 
-$: << File.join(File.dirname(__FILE__), "..", "..", "lib")
-
+$:.unshift '../../lib'
 require 'rack'
 require '../testrequest'
 

data/test/cgi/test.ru

@@ -1,5 +1,5 @@
-#!/usr/bin/env ruby ../../bin/rackup
-#\ -E deployment -I ~/projects/rack/lib
+#!/usr/bin/env ../../bin/rackup
+#\ -E deployment -I ../../lib
 # -*- ruby -*-
 
 require '../testrequest'

data/test/spec_rack_auth_openid.rb

@@ -0,0 +1,137 @@
+require 'test/spec'
+
+begin
+# requires the ruby-openid gem
+require 'rack/auth/openid'
+
+context "Rack::Auth::OpenID" do
+  OID = Rack::Auth::OpenID
+  realm = 'http://path/arf'
+  ruri = %w{arf arf/blargh}
+  auri = ruri.map{|u|'/'+u}
+  furi = auri.map{|u|'http://path'+u}
+
+  specify 'realm uri should be absolute and have a path' do
+    lambda{OID.new('/path')}.
+      should.raise ArgumentError
+    lambda{OID.new('http://path')}.
+      should.raise ArgumentError
+    lambda{OID.new('http://path/')}.
+      should.not.raise
+    lambda{OID.new('http://path/arf')}.
+      should.not.raise
+  end
+
+  specify 'uri options should be absolute' do
+    [:login_good, :login_fail, :login_quit, :return_to].each do |param|
+      ruri.each do |uri|
+        lambda{OID.new(realm, {param=>uri})}.
+          should.raise ArgumentError
+      end
+      auri.each do |uri|
+        lambda{OID.new(realm, {param=>uri})}.
+          should.raise ArgumentError
+      end
+      furi.each do |uri|
+        lambda{OID.new(realm, {param=>uri})}.
+          should.not.raise
+      end
+    end
+  end
+
+  specify 'return_to should be absolute and be under the realm' do
+    lambda{OID.new(realm, {:return_to => 'http://path'})}.
+      should.raise ArgumentError
+    lambda{OID.new(realm, {:return_to => 'http://path/'})}.
+      should.raise ArgumentError
+    lambda{OID.new(realm, {:return_to => 'http://path/arf'})}.
+      should.not.raise
+    lambda{OID.new(realm, {:return_to => 'http://path/arf/'})}.
+      should.not.raise
+    lambda{OID.new(realm, {:return_to => 'http://path/arf/blargh'})}.
+      should.not.raise
+  end
+
+  specify 'extensions should be a module' do
+    ext = Object.new
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(TypeError).
+      message.should.match(/not a module/)
+    ext2 = Module.new
+    lambda{OID.new(realm).add_extension(ext2)}.
+      should.raise(ArgumentError).
+      message.should.not.match(/not a module/)
+  end
+
+  specify 'extensions should have required constants defined' do
+    ext = Module.new
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(ArgumentError).
+      message.should.match(/missing/)
+    ext::Request = nil
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(ArgumentError).
+      message.should.match(/missing/).
+        should.not.match(/Request/)
+    ext::Response = nil
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(ArgumentError).
+      message.should.match(/missing/).
+        should.not.match(/Response/)
+    ext::NS_URI = nil
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(TypeError).
+      message.should.not.match(/missing/)
+  end
+
+  specify 'extensions should have Request and Response defined and inherit from OpenID::Extension' do
+$-w, w = nil, $-w               # yuck
+    ext = Module.new
+    ext::Request = nil
+    ext::Response = nil
+    ext::NS_URI = nil
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(TypeError).
+      message.should.match(/not a class/)
+    ext::Request = Class.new()
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(TypeError).
+      message.should.match(/not a class/)
+    ext::Response = Class.new()
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(ArgumentError).
+      message.should.match(/not a decendant/)
+    ext::Request = Class.new(::OpenID::Extension)
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(ArgumentError).
+      message.should.match(/not a decendant/)
+    ext::Response = Class.new(::OpenID::Extension)
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(TypeError).
+      message.should.match(/NS_URI/)
+$-w = w
+  end
+
+  specify 'extensions should have NS_URI defined and be a string of an absolute http uri' do
+$-w, w = nil, $-w               # yuck
+    ext = Module.new
+    ext::Request = Class.new(::OpenID::Extension)
+    ext::Response = Class.new(::OpenID::Extension)
+    ext::NS_URI = nil
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(TypeError).
+      message.should.match(/not a string/)
+    ext::NS_URI = 'openid.net'
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.raise(ArgumentError).
+      message.should.match(/not an http uri/)
+    ext::NS_URI = 'http://openid.net'
+    lambda{OID.new(realm).add_extension(ext)}.
+      should.not.raise
+$-w = w
+  end
+end
+
+rescue LoadError
+  $stderr.puts "Skipping Rack::Auth::OpenID tests (ruby-openid 2 is required). `gem install ruby-openid` and try again."
+end

data/test/spec_rack_camping.rb

@@ -2,46 +2,50 @@ require 'test/spec'
 require 'stringio'
 require 'uri'
 
-require 'rack/mock'
-
-$-w, w = nil, $-w               # yuck
-require 'camping'
-require 'rack/adapter/camping'
-
-Camping.goes :CampApp
-module CampApp
-  module Controllers
-    class HW < R('/')
-      def get
-        @headers["X-Served-By"] = URI("http://rack.rubyforge.org")
-        "Camping works!"
-      end
-
-      def post
-        "Data: #{input.foo}"
+begin
+  require 'rack/mock'
+
+  $-w, w = nil, $-w               # yuck
+  require 'camping'
+  require 'rack/adapter/camping'
+
+  Camping.goes :CampApp
+  module CampApp
+    module Controllers
+      class HW < R('/')
+        def get
+          @headers["X-Served-By"] = URI("http://rack.rubyforge.org")
+          "Camping works!"
+        end
+
+        def post
+          "Data: #{input.foo}"
+        end
       end
     end
   end
-end
-$-w = w
+  $-w = w
 
-context "Rack::Adapter::Camping" do
-  specify "works with GET" do
-    res = Rack::MockRequest.new(Rack::Adapter::Camping.new(CampApp)).
-      get("/")
+  context "Rack::Adapter::Camping" do
+    specify "works with GET" do
+      res = Rack::MockRequest.new(Rack::Adapter::Camping.new(CampApp)).
+        get("/")
 
-    res.should.be.ok
-    res["Content-Type"].should.equal "text/html"
-    res["X-Served-By"].should.equal "http://rack.rubyforge.org"
+      res.should.be.ok
+      res["Content-Type"].should.equal "text/html"
+      res["X-Served-By"].should.equal "http://rack.rubyforge.org"
 
-    res.body.should.equal "Camping works!"
-  end
+      res.body.should.equal "Camping works!"
+    end
 
-  specify "works with POST" do
-    res = Rack::MockRequest.new(Rack::Adapter::Camping.new(CampApp)).
-      post("/", :input => "foo=bar")
+    specify "works with POST" do
+      res = Rack::MockRequest.new(Rack::Adapter::Camping.new(CampApp)).
+        post("/", :input => "foo=bar")
 
-    res.should.be.ok
-    res.body.should.equal "Data: bar"
+      res.should.be.ok
+      res.body.should.equal "Data: bar"
+    end
   end
+rescue LoadError
+  $stderr.puts "Skipping Rack::Adapter::Camping tests (Camping is required). `gem install camping` and try again."
 end

data/test/spec_rack_cascade.rb

@@ -32,4 +32,19 @@ context "Rack::Cascade" do
     lambda { Rack::MockRequest.new(Rack::Cascade.new([])).get("/") }.
       should.raise(ArgumentError)
   end
+
+  specify "should append new app" do
+    cascade = Rack::Cascade.new([], [404, 403])
+    lambda { Rack::MockRequest.new(cascade).get('/cgi/test') }.
+      should.raise(ArgumentError)
+    cascade << app2
+    Rack::MockRequest.new(cascade).get('/cgi/test').should.be.not_found
+    Rack::MockRequest.new(cascade).get('/cgi/../bla').should.be.not_found
+    cascade << app1
+    Rack::MockRequest.new(cascade).get('/cgi/test').should.be.ok
+    Rack::MockRequest.new(cascade).get('/cgi/../bla').should.be.forbidden
+    Rack::MockRequest.new(cascade).get('/foo').should.be.not_found
+    cascade << app3
+    Rack::MockRequest.new(cascade).get('/foo').should.be.ok
+  end
 end