3mix-castronaut 0.5.0.2

data/vendor/rack/test/spec_rack_utils.rb

@@ -0,0 +1,174 @@
+require 'test/spec'
+
+require 'rack/utils'
+require 'rack/lint'
+require 'rack/mock'
+
+context "Rack::Utils" do
+  specify "should escape correctly" do
+    Rack::Utils.escape("fo<o>bar").should.equal "fo%3Co%3Ebar"
+    Rack::Utils.escape("a space").should.equal "a+space"
+    Rack::Utils.escape("q1!2\"'w$5&7/z8)?\\").
+      should.equal "q1%212%22%27w%245%267%2Fz8%29%3F%5C"
+  end
+
+  specify "should unescape correctly" do
+    Rack::Utils.unescape("fo%3Co%3Ebar").should.equal "fo<o>bar"
+    Rack::Utils.unescape("a+space").should.equal "a space"
+    Rack::Utils.unescape("a%20space").should.equal "a space"
+    Rack::Utils.unescape("q1%212%22%27w%245%267%2Fz8%29%3F%5C").
+      should.equal "q1!2\"'w$5&7/z8)?\\"
+  end
+
+  specify "should parse query strings correctly" do
+    Rack::Utils.parse_query("foo=bar").should.equal "foo" => "bar"
+    Rack::Utils.parse_query("foo=bar&foo=quux").
+      should.equal "foo" => ["bar", "quux"]
+    Rack::Utils.parse_query("foo=1&bar=2").
+      should.equal "foo" => "1", "bar" => "2"
+    Rack::Utils.parse_query("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F").
+      should.equal "my weird field" => "q1!2\"'w$5&7/z8)?"
+  end
+  
+  specify "should build query strings correctly" do
+    Rack::Utils.build_query("foo" => "bar").should.equal "foo=bar"
+    Rack::Utils.build_query("foo" => ["bar", "quux"]).
+      should.equal "foo=bar&foo=quux"
+    Rack::Utils.build_query("foo" => "1", "bar" => "2").
+      should.equal "foo=1&bar=2"
+    Rack::Utils.build_query("my weird field" => "q1!2\"'w$5&7/z8)?").
+      should.equal "my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F"
+  end
+
+  specify "should figure out which encodings are acceptable" do
+    helper = lambda do |a, b|
+      request = Rack::Request.new(Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => a))
+      Rack::Utils.select_best_encoding(a, b)
+    end
+
+    helper.call(%w(), [["x", 1]]).should.equal(nil)
+    helper.call(%w(identity), [["identity", 0.0]]).should.equal(nil)
+    helper.call(%w(identity), [["*", 0.0]]).should.equal(nil)
+
+    helper.call(%w(identity), [["compress", 1.0], ["gzip", 1.0]]).should.equal("identity")
+
+    helper.call(%w(compress gzip identity), [["compress", 1.0], ["gzip", 1.0]]).should.equal("compress")
+    helper.call(%w(compress gzip identity), [["compress", 0.5], ["gzip", 1.0]]).should.equal("gzip")
+
+    helper.call(%w(foo bar identity), []).should.equal("identity")
+    helper.call(%w(foo bar identity), [["*", 1.0]]).should.equal("foo")
+    helper.call(%w(foo bar identity), [["*", 1.0], ["foo", 0.9]]).should.equal("bar")
+
+    helper.call(%w(foo bar identity), [["foo", 0], ["bar", 0]]).should.equal("identity")
+    helper.call(%w(foo bar baz identity), [["*", 0], ["identity", 0.1]]).should.equal("identity")
+  end
+end
+
+context "Rack::Utils::HeaderHash" do
+  specify "should capitalize on all accesses" do
+    h = Rack::Utils::HeaderHash.new("foo" => "bar")
+    h["foo"].should.equal "bar"
+    h["Foo"].should.equal "bar"
+    h["FOO"].should.equal "bar"
+
+    h.to_hash.should.equal "Foo" => "bar"
+
+    h["bar-zzle"] = "quux"
+
+    h.to_hash.should.equal "Foo" => "bar", "Bar-Zzle" => "quux"
+  end
+
+  specify "should capitalize correctly" do
+    h = Rack::Utils::HeaderHash.new
+
+    h.capitalize("foo").should.equal "Foo"
+    h.capitalize("foo-bar").should.equal "Foo-Bar"
+    h.capitalize("foo_bar").should.equal "Foo_Bar"
+    h.capitalize("foo bar").should.equal "Foo Bar"
+    h.capitalize("foo-bar-quux").should.equal "Foo-Bar-Quux"
+    h.capitalize("foo-bar-2quux").should.equal "Foo-Bar-2quux"
+  end
+
+  specify "should be converted to real Hash" do
+    h = Rack::Utils::HeaderHash.new("foo" => "bar")
+    h.to_hash.should.be.instance_of Hash
+  end
+end
+
+context "Rack::Utils::Context" do
+  test_app1 = Object.new
+  def test_app1.context app
+    Rack::Utils::Context.new self, app do |env|
+      app.call env
+    end
+  end
+  test_app2 = Object.new
+  def test_app2.context env; end
+  test_app3 = Object.new
+  test_target1 = proc{|e| e.to_s+' world' }
+  test_target2 = proc{|e| e.to_i+2 }
+  test_target3 = proc{|e| nil }
+  test_target4 = proc{|e| [200,{'Content-Type'=>'text/plain', 'Content-Length'=>'0'},['']] }
+  test_target5 = Object.new
+
+  specify "should perform checks on both arguments" do
+    lambda { Rack::Utils::Context.new(nil, nil){} }.should.raise
+    lambda { Rack::Utils::Context.new(test_app1, nil){} }.should.raise
+    lambda { Rack::Utils::Context.new(nil, test_target1){} }.should.raise
+    lambda { Rack::Utils::Context.new(test_app1, test_target1){} }.should.not.raise
+    lambda { Rack::Utils::Context.new(test_app3, test_target1){} }.should.raise
+    lambda { Rack::Utils::Context.new(test_app1, test_target5){} }.should.raise
+    lambda { test_app1.context(nil){} }.should.raise
+    lambda { test_app1.context(test_target1){} }.should.not.raise
+    lambda { test_app1.context(test_target5){} }.should.raise
+  end
+
+  specify "should set context correctly" do
+    c1 = Rack::Utils::Context.new(test_app1, test_target1){}
+    c1.for.should.equal test_app1
+    c1.app.should.equal test_target1
+    c2 = Rack::Utils::Context.new(test_app1, test_target2){}
+    c2.for.should.equal test_app1
+    c2.app.should.equal test_target2
+    c3 = Rack::Utils::Context.new(test_app2, test_target3){}
+    c3.for.should.equal test_app2
+    c3.app.should.equal test_target3
+    c4 = Rack::Utils::Context.new(test_app2, test_target4){}
+    c4.for.should.equal test_app2
+    c4.app.should.equal test_target4
+  end
+
+  specify "should alter app on recontexting" do
+    c1 = Rack::Utils::Context.new(test_app1, test_target1){}
+    c1.for.should.equal test_app1
+    c1.app.should.equal test_target1
+    c2 = c1.context(test_target2)
+    c2.for.should.equal test_app1
+    c2.app.should.not.equal test_target1
+    c2.app.should.equal test_target2
+    c3 = c2.context(test_target3)
+    c3.for.should.equal test_app1
+    c3.app.should.not.equal test_target2
+    c3.app.should.equal test_target3
+    c4 = c3.context(test_target4)
+    c4.for.should.equal test_app1
+    c4.app.should.not.equal test_target3
+    c4.app.should.equal test_target4
+  end
+
+  specify "should run different apps" do
+    c1 = test_app1.context(test_target1)
+    c2 = c1.context test_target2
+    c3 = c2.context test_target3
+    c4 = c3.context test_target4
+    a4 = Rack::Lint.new c4
+    r1 = c1.call('hello')
+    r1.should.equal 'hello world'
+    r2 = c2.call(2)
+    r2.should.equal 4
+    r3 = c3.call(:misc_symbol)
+    r3.should.be.nil
+    r4 = Rack::MockRequest.new(a4).get('/')
+    r4.status.should.be 200
+  end
+end

data/vendor/rack/test/spec_rack_webrick.rb

@@ -0,0 +1,106 @@
+require 'test/spec'
+
+require 'rack/handler/webrick'
+require 'rack/lint'
+require 'testrequest'
+
+Thread.abort_on_exception = true
+
+context "Rack::Handler::WEBrick" do
+  include TestRequest::Helpers
+  
+  setup do
+    @server = WEBrick::HTTPServer.new(:Host => @host='0.0.0.0',
+                                      :Port => @port=9202,
+                                      :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
+                                      :AccessLog => [])
+    @server.mount "/test", Rack::Handler::WEBrick,
+      Rack::Lint.new(TestRequest.new)
+    Thread.new { @server.start }
+    trap(:INT) { @server.shutdown }
+  end
+
+  specify "should respond" do
+    lambda {
+      GET("/test")
+    }.should.not.raise
+  end
+
+  specify "should be a WEBrick" do
+    GET("/test")
+    status.should.be 200
+    response["SERVER_SOFTWARE"].should =~ /WEBrick/
+    response["HTTP_VERSION"].should.equal "HTTP/1.1"
+    response["SERVER_PROTOCOL"].should.equal "HTTP/1.1"
+    response["SERVER_PORT"].should.equal "9202"
+    response["SERVER_NAME"].should.equal "0.0.0.0"
+  end
+
+  specify "should have rack headers" do
+    GET("/test")
+    response["rack.version"].should.equal [0,1]
+    response["rack.multithread"].should.be true
+    response["rack.multiprocess"].should.be false
+    response["rack.run_once"].should.be false
+  end
+
+  specify "should have CGI headers on GET" do
+    GET("/test")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["SCRIPT_NAME"].should.equal "/test"
+    response["REQUEST_PATH"].should.equal "/"
+    response["PATH_INFO"].should.be.nil
+    response["QUERY_STRING"].should.equal ""
+    response["test.postdata"].should.equal ""
+
+    GET("/test/foo?quux=1")
+    response["REQUEST_METHOD"].should.equal "GET"
+    response["SCRIPT_NAME"].should.equal "/test"
+    response["REQUEST_PATH"].should.equal "/"
+    response["PATH_INFO"].should.equal "/foo"
+    response["QUERY_STRING"].should.equal "quux=1"
+  end
+
+  specify "should have CGI headers on POST" do
+    POST("/test", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
+    status.should.equal 200
+    response["REQUEST_METHOD"].should.equal "POST"
+    response["SCRIPT_NAME"].should.equal "/test"
+    response["REQUEST_PATH"].should.equal "/"
+    response["QUERY_STRING"].should.equal ""
+    response["HTTP_X_TEST_HEADER"].should.equal "42"
+    response["test.postdata"].should.equal "rack-form-data=23"
+  end
+
+  specify "should support HTTP auth" do
+    GET("/test", {:user => "ruth", :passwd => "secret"})
+    response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ="
+  end
+
+  specify "should set status" do
+    GET("/test?secret")
+    status.should.equal 403
+    response["rack.url_scheme"].should.equal "http"
+  end
+
+  specify "should provide a .run" do
+    block_ran = false
+    catch(:done) {
+      Rack::Handler::WEBrick.run(lambda {},
+                                 {:Port => 9210,
+                                   :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN),
+                                   :AccessLog => []}) { |server|
+        block_ran = true
+        server.should.be.kind_of WEBrick::HTTPServer
+        @s = server
+        throw :done
+      }
+    }
+    block_ran.should.be true
+    @s.shutdown
+  end
+
+  teardown do
+    @server.shutdown
+  end
+end

data/vendor/rack/test/testrequest.rb

@@ -0,0 +1,45 @@
+require 'yaml'
+require 'net/http'
+
+class TestRequest
+  def call(env)
+    status = env["QUERY_STRING"] =~ /secret/ ? 403 : 200
+    env["test.postdata"] = env["rack.input"].read
+    body = env.to_yaml
+    size = body.respond_to?(:bytesize) ? body.bytesize : body.size
+    [status, {"Content-Type" => "text/yaml", "Content-Length" => size.to_s}, [body]]
+  end
+
+  module Helpers
+    attr_reader :status, :response
+
+    def GET(path, header={})
+      Net::HTTP.start(@host, @port) { |http|
+        user = header.delete(:user)
+        passwd = header.delete(:passwd)
+
+        get = Net::HTTP::Get.new(path, header)
+        get.basic_auth user, passwd  if user && passwd
+        http.request(get) { |response|
+          @status = response.code.to_i
+          @response = YAML.load(response.body)
+        }
+      }
+    end
+
+    def POST(path, formdata={}, header={})
+      Net::HTTP.start(@host, @port) { |http|
+        user = header.delete(:user)
+        passwd = header.delete(:passwd)
+
+        post = Net::HTTP::Post.new(path, header)
+        post.form_data = formdata
+        post.basic_auth user, passwd  if user && passwd
+        http.request(post) { |response|
+          @status = response.code.to_i
+          @response = YAML.load(response.body)
+        }
+      }
+    end
+  end
+end

data/vendor/sinatra/CHANGELOG

@@ -0,0 +1,64 @@
+= 0.3.0
+
+  * Add sinatra.gemspec w/ support for github gem builds. Forks can now
+    enable the build gem option in github to get free username-sinatra.gem
+    builds: gem install username-sinatra.gem --source=http://gems.github.com/
+
+  * Require rack-0.4 gem; removes frozen rack dir.
+
+  * Basic RSpec support; require 'sinatra/test/rspec' instead of
+    'sinatra/test/spec' to use. [avdi]
+
+  * before filters can modify request environment vars used for
+    routing (e.g., PATH_INFO, REQUEST_METHOD, etc.) for URL rewriting
+    type functionality.
+
+  * In-file templates now uses @@ instead of ## as template separator.
+
+  * Top-level environment test predicates: development?, test?, production?
+
+  * Top-level "set", "enable", and "disable" methods for tweaking
+    app options. [rtomayko]
+
+  * Top-level "use" method for building Rack middleware pipelines
+    leading to app. See README for usage. [rtomayko]
+
+  * New "reload" option - set false to disable reloading in development.
+
+  * New "host" option - host/ip to bind to [cschneid]
+
+  * New "app_file" option - override the file to reload in development
+    mode [cschneid]
+
+  * Development error/not_found page cleanup [sr, adamwiggins]
+
+  * Remove a bunch of core extensions (String#to_param, String#from_param,
+    Hash#from_params, Hash#to_params, Hash#symbolize_keys, Hash#pass)
+
+  * Various grammar and formatting fixes to README; additions on
+    community and contributing [cypher]
+
+  * Build RDoc using Hanna template: http://sinatrarb.rubyforge.org/api
+
+  * Specs, documentation and fixes for splat'n routes [vic]
+
+  * Fix whitespace errors across all source files. [rtomayko]
+
+  * Fix streaming issues with Mongrel (body not closed). [bmizerany]
+
+  * Fix various issues with environment not being set properly (configure
+    blocks not running, error pages not registering, etc.) [cypher]
+
+  * Fix to allow locals to be passed to ERB templates [cschneid]
+
+  * Fix locking issues causing random errors during reload in development.
+
+  * Fix for escaped paths not resolving static files [Matthew Walker]
+
+= 0.2.1
+
+  * File upload fix and minor tweaks.
+
+= 0.2.0
+
+  * Initial gem release of 0.2 coebase.

data/vendor/sinatra/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007 Blake Mizerany
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.