rack 1.1.6 → 1.2.0

data/lib/rack/adapter/camping.rb

@@ -1,22 +0,0 @@
-module Rack
-  module Adapter
-    class Camping
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        env["PATH_INFO"] ||= ""
-        env["SCRIPT_NAME"] ||= ""
-        controller = @app.run(env['rack.input'], env)
-        h = controller.headers
-        h.each_pair do |k,v|
-          if v.kind_of? URI
-            h[k] = v.to_s
-          end
-        end
-        [controller.status, controller.headers, [controller.body.to_s]]
-      end
-    end
-  end
-end

data/test/spec_auth.rb

@@ -1,57 +0,0 @@
-require 'rack'
-
-context "Rack::Auth" do
-  specify "should have all common authentication schemes" do
-    Rack::Auth.schemes.should.include? 'basic'
-    Rack::Auth.schemes.should.include? 'digest'
-    Rack::Auth.schemes.should.include? 'bearer'
-    Rack::Auth.schemes.should.include? 'token'
-  end
-
-  specify "should allow registration of new auth schemes" do
-    Rack::Auth.schemes.should.not.include "test"
-    Rack::Auth.add_scheme "test"
-    Rack::Auth.schemes.should.include "test"
-  end
-end
-
-context "Rack::Auth::AbstractRequest" do
-  specify "should symbolize known auth schemes" do
-    env = Rack::MockRequest.env_for('/')
-    env['HTTP_AUTHORIZATION'] = 'Basic aXJyZXNwb25zaWJsZQ=='
-    req = Rack::Auth::AbstractRequest.new(env)
-    req.scheme.should.equal :basic
-
-
-    env['HTTP_AUTHORIZATION'] = 'Digest aXJyZXNwb25zaWJsZQ=='
-    req = Rack::Auth::AbstractRequest.new(env)
-    req.scheme.should.equal :digest
-
-    env['HTTP_AUTHORIZATION'] = 'Bearer aXJyZXNwb25zaWJsZQ=='
-    req = Rack::Auth::AbstractRequest.new(env)
-    req.scheme.should.equal :bearer
-
-    env['HTTP_AUTHORIZATION'] = 'MAC aXJyZXNwb25zaWJsZQ=='
-    req = Rack::Auth::AbstractRequest.new(env)
-    req.scheme.should.equal :mac
-
-    env['HTTP_AUTHORIZATION'] = 'Token aXJyZXNwb25zaWJsZQ=='
-    req = Rack::Auth::AbstractRequest.new(env)
-    req.scheme.should.equal :token
-
-    env['HTTP_AUTHORIZATION'] = 'OAuth aXJyZXNwb25zaWJsZQ=='
-    req = Rack::Auth::AbstractRequest.new(env)
-    req.scheme.should.equal :oauth
-
-    env['HTTP_AUTHORIZATION'] = 'OAuth2 aXJyZXNwb25zaWJsZQ=='
-    req = Rack::Auth::AbstractRequest.new(env)
-    req.scheme.should.equal :oauth2
-  end
-
-  specify "should not symbolize unknown auth schemes" do
-    env = Rack::MockRequest.env_for('/')
-    env['HTTP_AUTHORIZATION'] = 'magic aXJyZXNwb25zaWJsZQ=='
-    req = Rack::Auth::AbstractRequest.new(env)
-    req.scheme.should == "magic"
-  end
-end

data/test/spec_rack_camping.rb

@@ -1,55 +0,0 @@
-require 'test/spec'
-require 'stringio'
-require 'uri'
-
-begin
-  require 'rack/mock'
-
-  $-w, w = nil, $-w               # yuck
-
-  # campings dependencies also don't pull this in anymore:
-  class Object;def meta_def m,&b;(class<<self;self;end).send:define_method,m,&b end end
-
-  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
-  $-w = w
-
-  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.body.should.equal "Camping works!"
-    end
-
-    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"
-    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_rewindable_input.rb

@@ -1,118 +0,0 @@
-require 'test/spec'
-require 'stringio'
-require 'rack/rewindable_input'
-
-shared_context "a rewindable IO object" do
-  setup do
-    @rio = Rack::RewindableInput.new(@io)
-  end
-  
-  teardown do
-    @rio.close
-  end
-  
-  specify "should be able to handle to read()" do
-    @rio.read.should.equal "hello world"
-  end
-  
-  specify "should be able to handle to read(nil)" do
-    @rio.read(nil).should.equal "hello world"
-  end
-  
-  specify "should be able to handle to read(length)" do
-    @rio.read(1).should.equal "h"
-  end
-  
-  specify "should be able to handle to read(length, buffer)" do
-    buffer = ""
-    result = @rio.read(1, buffer)
-    result.should.equal "h"
-    result.object_id.should.equal buffer.object_id
-  end
-  
-  specify "should be able to handle to read(nil, buffer)" do
-    buffer = ""
-    result = @rio.read(nil, buffer)
-    result.should.equal "hello world"
-    result.object_id.should.equal buffer.object_id
-  end
-  
-  specify "should rewind to the beginning when #rewind is called" do
-    @rio.read(1)
-    @rio.rewind
-    @rio.read.should.equal "hello world"
-  end
-  
-  specify "should be able to handle gets" do
-    @rio.gets.should == "hello world"
-  end
-  
-  specify "should be able to handle each" do
-    array = []
-    @rio.each do |data|
-      array << data
-    end
-    array.should.equal(["hello world"])
-  end
-  
-  specify "should not buffer into a Tempfile if no data has been read yet" do
-    @rio.instance_variable_get(:@rewindable_io).should.be.nil
-  end
-  
-  specify "should buffer into a Tempfile when data has been consumed for the first time" do
-    @rio.read(1)
-    tempfile = @rio.instance_variable_get(:@rewindable_io)
-    tempfile.should.not.be.nil
-    @rio.read(1)
-    tempfile2 = @rio.instance_variable_get(:@rewindable_io)
-    tempfile2.should.equal tempfile
-  end
-  
-  specify "should close the underlying tempfile upon calling #close" do
-    @rio.read(1)
-    tempfile = @rio.instance_variable_get(:@rewindable_io)
-    @rio.close
-    tempfile.should.be.closed
-  end
-  
-  specify "should be possibel to call #close when no data has been buffered yet" do
-    @rio.close
-  end
-  
-  specify "should be possible to call #close multiple times" do
-    @rio.close
-    @rio.close
-  end
-end
-
-context "Rack::RewindableInput" do
-  context "given an IO object that is already rewindable" do
-    setup do
-      @io = StringIO.new("hello world")
-    end
-    
-    it_should_behave_like "a rewindable IO object"
-  end
-  
-  context "given an IO object that is not rewindable" do
-    setup do
-      @io = StringIO.new("hello world")
-      @io.instance_eval do
-        undef :rewind
-      end
-    end
-    
-    it_should_behave_like "a rewindable IO object"
-  end
-  
-  context "given an IO object whose rewind method raises Errno::ESPIPE" do
-    setup do
-      @io = StringIO.new("hello world")
-      def @io.rewind
-        raise Errno::ESPIPE, "You can't rewind this!"
-      end
-    end
-    
-    it_should_behave_like "a rewindable IO object"
-  end
-end

data/test/spec_rack_showexceptions.rb

@@ -1,21 +0,0 @@
-require 'test/spec'
-
-require 'rack/showexceptions'
-require 'rack/mock'
-
-context "Rack::ShowExceptions" do
-  specify "catches exceptions" do
-    res = nil
-    req = Rack::MockRequest.new(Rack::ShowExceptions.new(lambda { |env|
-                                                           raise RuntimeError
-                                                         }))
-    lambda {
-      res = req.get("/")
-    }.should.not.raise
-    res.should.be.a.server_error
-    res.status.should.equal 500
-
-    res.should =~ /RuntimeError/
-    res.should =~ /ShowExceptions/
-  end
-end

data/test/spec_rack_showstatus.rb

@@ -1,72 +0,0 @@
-require 'test/spec'
-
-require 'rack/showstatus'
-require 'rack/mock'
-
-context "Rack::ShowStatus" do
-  specify "should provide a default status message" do
-    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
-                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
-                                                     }))
-
-    res = req.get("/", :lint => true)
-    res.should.be.not_found
-    res.should.be.not.empty
-
-    res["Content-Type"].should.equal("text/html")
-    res.should =~ /404/
-    res.should =~ /Not Found/
-  end
-
-  specify "should let the app provide additional information" do
-    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
-                                                       env["rack.showstatus.detail"] = "gone too meta."
-                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
-                                                     }))
-
-    res = req.get("/", :lint => true)
-    res.should.be.not_found
-    res.should.be.not.empty
-
-    res["Content-Type"].should.equal("text/html")
-    res.should =~ /404/
-    res.should =~ /Not Found/
-    res.should =~ /too meta/
-  end
-
-  specify "should not replace existing messages" do
-    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
-                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
-                                                     }))
-    res = req.get("/", :lint => true)
-    res.should.be.not_found
-
-    res.body.should == "foo!"
-  end
-
-  specify "should pass on original headers" do
-    headers = {"WWW-Authenticate" => "Basic blah"}
-
-    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env| [401, headers, []] }))
-    res = req.get("/", :lint => true)
-
-    res["WWW-Authenticate"].should.equal("Basic blah")
-  end
-
-  specify "should replace existing messages if there is detail" do
-    req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env|
-                                                       env["rack.showstatus.detail"] = "gone too meta."
-                                                       [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]]
-                                                     }))
-
-    res = req.get("/", :lint => true)
-    res.should.be.not_found
-    res.should.be.not.empty
-
-    res["Content-Type"].should.equal("text/html")
-    res["Content-Length"].should.not.equal("4")
-    res.should =~ /404/
-    res.should =~ /too meta/
-    res.body.should.not =~ /foo/
-  end
-end

data/test/spec_rackup.rb

@@ -1,164 +0,0 @@
-require 'test/spec'
-require 'testrequest'
-require 'rack/server'
-require 'open3'
-
-begin
-require "mongrel"
-
-context "rackup" do
-  include TestRequest::Helpers
-
-  def run_rackup(*args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    flags   = args.first
-    @host = options[:host] || "0.0.0.0"
-    @port = options[:port] || 9292
-
-    Dir.chdir("#{root}/test/rackup") do
-      @in, @rackup, @err = Open3.popen3("#{ruby} -S #{rackup} #{flags}")
-    end
-
-    return if options[:port] == false
-
-    # Wait until the server is available
-    i = 0
-    begin
-      GET("/")
-    rescue
-      i += 1
-      if i > 40
-        Dir["#{root}/**/*.pid"].each {|f|
-          Process.kill(9, File.read(f)) rescue nil
-          File.delete(f)
-        }
-        raise "Server did not start"
-      end
-      sleep 0.05
-      retry
-    end
-  end
-
-  def output
-    @rackup.read
-  end
-
-  after do
-    # This doesn't actually return a response, so we rescue
-    GET "/die" rescue nil
-
-    Dir["#{root}/**/*.pid"].each do |file|
-      Process.kill(9, File.read(file).strip.to_i) rescue nil
-      File.delete(file)
-    end
-
-    File.delete("#{root}/log_output") if File.exist?("#{root}/log_output")
-  end
-
-  specify "rackup" do
-    run_rackup
-    response["PATH_INFO"].should.equal '/'
-    response["test.$DEBUG"].should.be false
-    response["test.$EVAL"].should.be nil
-    response["test.$VERBOSE"].should.be false
-    response["test.Ping"].should.be nil
-    response["SERVER_SOFTWARE"].should.not =~ /webrick/
-  end
-
-  specify "rackup --help" do
-    run_rackup "--help", :port => false
-    output.should.match /--port/
-  end
-
-  specify "rackup --port" do
-    run_rackup "--port 9000", :port => 9000
-    response["SERVER_PORT"].should.equal "9000"
-  end
-
-  specify "rackup --debug" do
-    run_rackup "--debug"
-    response["test.$DEBUG"].should.be true
-  end
-
-  specify "rackup --eval" do
-    run_rackup %{--eval "BUKKIT = 'BUKKIT'"}
-    response["test.$EVAL"].should.equal "BUKKIT"
-  end
-
-  specify "rackup --warn" do
-    run_rackup %{--warn}
-    response["test.$VERBOSE"].should.be true
-  end
-
-  specify "rackup --include" do
-    run_rackup %{--include /foo/bar}
-    response["test.$LOAD_PATH"].should.include "/foo/bar"
-  end
-
-  specify "rackup --require" do
-    run_rackup %{--require ping}
-    response["test.Ping"].should.equal "constant"
-  end
-
-  specify "rackup --server" do
-    run_rackup %{--server webrick}
-    response["SERVER_SOFTWARE"].should =~ /webrick/i
-  end
-
-  specify "rackup --host" do
-    run_rackup %{--host 127.0.0.1}, :host => "127.0.0.1"
-    response["REMOTE_ADDR"].should.equal "127.0.0.1"
-  end
-
-  specify "rackup --daemonize --pid" do
-    run_rackup "--daemonize --pid testing.pid"
-    status.should.be 200
-    @rackup.should.be.eof?
-    Dir["#{root}/**/testing.pid"].should.not.be.empty?
-  end
-
-  specify "rackup --pid" do
-    run_rackup %{--pid testing.pid}
-    status.should.be 200
-    Dir["#{root}/**/testing.pid"].should.not.be.empty?
-  end
-
-  specify "rackup --version" do
-    run_rackup %{--version}, :port => false
-    output.should =~ /Rack 1.1/
-  end
-
-  specify "rackup --env development includes lint" do
-    run_rackup
-    GET("/broken_lint")
-    status.should.be 500
-  end
-
-  specify "rackup --env deployment does not include lint" do
-    run_rackup %{--env deployment}
-    GET("/broken_lint")
-    status.should.be 200
-  end
-
-  specify "rackup --env none does not include lint" do
-    run_rackup %{--env none}
-    GET("/broken_lint")
-    status.should.be 200
-  end
-
-  specify "rackup --env deployment does log" do
-    run_rackup %{--env deployment}
-    log = File.read(response["test.stderr"])
-    log.should.be.empty?
-  end
-
-  specify "rackup --env none does not log" do
-    run_rackup %{--env none}
-    GET("/")
-    log = File.read(response["test.stderr"])
-    log.should.be.empty?
-  end
-end
-rescue LoadError
-  $stderr.puts "Skipping rackup --server tests (mongrel is required). `gem install thin` and try again."
-end