webmachine 0.4.1 → 0.4.2

data/pkg/webmachine-0.2.0/pkg/webmachine-0.1.0/spec/webmachine/dispatcher/route_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Dispatcher::Route do
-  let(:request){ Webmachine::Request.new("GET", URI.parse("http://localhost:8098/"), Webmachine::Headers.new, "") }
-  let(:resource){ Class.new(Webmachine::Resource) }
-
-  matcher :match_route do |*expected|
-    route = described_class.new(expected[0], resource, expected[1] || {})
-    match do |actual|
-      request.uri.path = actual if String === actual
-      route.match?(request)
-    end
-
-    failure_message_for_should do |_|
-      "expected route #{expected[0].inspect} to match path #{request.uri.path}"
-    end
-    failure_message_for_should_not do |_|
-      "expected route #{expected[0].inspect} not to match path #{request.uri.path}"
-    end
-  end
-
-  context "matching a request" do
-    context "on the root path" do
-      subject { "/" }
-      it { should match_route([]) }
-      it { should match_route ['*'] }
-      it { should_not match_route %w{foo} }
-      it { should_not match_route [:id] }
-    end
-
-    context "on a deep path" do
-      subject { "/foo/bar/baz" }
-      it { should match_route %w{foo bar baz} }
-      it { should match_route ['foo', :id, "baz"] }
-      it { should match_route %w{foo *} }
-      it { should match_route [:id, '*'] }
-      it { should_not match_route [] }
-      it { should_not match_route %w{bar *} }
-    end
-  end
-
-  context "applying bindings" do
-    context "on the root path" do
-      subject { described_class.new([], resource) }
-      before { subject.apply(request) }
-
-      it "should assign the dispatched path to the empty string" do
-        request.disp_path.should == ""
-      end
-
-      it "should assign empty bindings" do
-        request.path_info.should == {}
-      end
-
-      it "should assign empty path tokens" do
-        request.path_tokens.should == []
-      end
-
-      context "with extra user-defined bindings" do
-        subject { described_class.new([], resource, "bar" => "baz") }
-
-        it "should assign the user-defined bindings" do
-          request.path_info.should == {"bar" => "baz"}
-        end
-      end
-
-      context "with a splat" do
-        subject { described_class.new(['*'], resource) }
-        
-        it "should assign empty path tokens" do
-          request.path_tokens.should == []
-        end
-      end
-    end
-
-    context "on a deep path" do
-      subject { described_class.new(%w{foo bar baz}, resource) }
-      before { request.uri.path = "/foo/bar/baz"; subject.apply(request) }
-
-      it "should assign the dispatched path as the path past the initial slash" do
-        request.disp_path.should == "foo/bar/baz"
-      end
-
-      it "should assign empty bindings" do
-        request.path_info.should == {}
-      end
-
-      it "should assign empty path tokens" do
-        request.path_tokens.should == []
-      end
-
-      context "with path variables" do
-        subject { described_class.new(['foo', :id, 'baz'], resource) }
-
-        it "should assign the path variables in the bindings" do
-          request.path_info.should == {:id => "bar"}
-        end
-      end
-
-      context "with a splat" do
-        subject { described_class.new(%w{foo *}, resource) }
-
-        it "should capture the path tokens matched by the splat" do
-          request.path_tokens.should == %w{ bar baz }
-        end
-      end
-    end
-  end
-end

data/pkg/webmachine-0.2.0/pkg/webmachine-0.1.0/spec/webmachine/dispatcher_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Dispatcher do
-  let(:dispatcher) { described_class }
-  let(:request) { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/"), Webmachine::Headers["accept" => "*/*"], "") }
-  let(:response) { Webmachine::Response.new }
-  let(:resource) do
-    Class.new(Webmachine::Resource) do
-      def to_html; "hello world!"; end
-    end
-  end
-  let(:resource2) do
-    Class.new(Webmachine::Resource) do
-      def to_html; "goodbye, cruel world"; end
-    end
-  end
-  let(:fsm){ mock }
-  
-  before { dispatcher.reset }
-  
-  it "should add routes" do
-    expect {
-      dispatcher.add_route ['*'], resource
-    }.should_not raise_error
-  end
-
-  it "should route to the proper resource" do
-    dispatcher.add_route ["goodbye"], resource2
-    dispatcher.add_route ['*'], resource    
-    Webmachine::Decision::FSM.should_receive(:new).with(instance_of(resource), request, response).and_return(fsm)
-    fsm.should_receive(:run)
-    dispatcher.dispatch(request, response)
-  end
-end

data/pkg/webmachine-0.2.0/pkg/webmachine-0.1.0/spec/webmachine/headers_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Headers do
-  it "should set and access values insensitive to case" do
-    subject['Content-TYPE'] = "text/plain"
-    subject['CONTENT-TYPE'].should == 'text/plain'
-  end
-
-  context "filtering with #grep" do
-    subject { described_class["content-type" => "text/plain", "etag" => '"abcdef1234567890"'] }
-    it "should filter keys by the given pattern" do
-      subject.grep(/content/i).should include("content-type")
-    end
-
-    it "should return a Headers instance" do
-      subject.grep(/etag/i).should be_instance_of(described_class)
-    end
-  end
-end

data/pkg/webmachine-0.2.0/pkg/webmachine-0.1.0/spec/webmachine/request_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Request do
-  subject { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/some/resource"), Webmachine::Headers.new, "") }
-  it "should provide access to the headers via brackets" do
-    subject.headers['Accept'] = "*/*"
-    subject["accept"].should == "*/*"
-  end
-
-  it "should provide access to the headers via underscored methods" do
-    subject.headers["Accept-Encoding"] = "identity"
-    subject.accept_encoding.should == "identity"
-    subject.content_md5.should be_nil
-  end
-
-  it "should calculate a base URI" do
-    subject.base_uri.should == URI.parse("http://localhost:8080/")
-  end
-
-  it "should provide a hash of query parameters" do
-    subject.uri.query = "foo=bar&baz=bam"
-    subject.query.should == {"foo" => "bar", "baz" => "bam"}
-  end
-end

data/pkg/webmachine-0.2.0/pkg/webmachine-0.1.0/webmachine.gemspec

@@ -1,44 +0,0 @@
-$:.push File.expand_path("../lib", __FILE__)
-require 'webmachine/version'
-
-Gem::Specification.new do |gem|
-  gem.name = "webmachine"
-  gem.version = Webmachine::VERSION
-  gem.date = File.mtime("lib/webmachine/version.rb")
-  gem.summary = %Q{webmachine is a toolkit for building HTTP applications,}
-  gem.description = <<-DESC.gsub(/\s+/, ' ')
-    webmachine is a toolkit for building HTTP applications in a declarative fashion, that avoids
-    the confusion of going through a CGI-style interface like Rack. It is strongly influenced
-    by the original Erlang project of the same name and shares its opinionated nature about HTTP.
-  DESC
-  gem.homepage = "http://github.com/seancribbs/webmachine-ruby"
-  gem.authors = ["Sean Cribbs"]
-  gem.email = ["sean@basho.com"]
-
-  if gem.respond_to? :specification_version then
-    gem.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      gem.add_runtime_dependency(%q<i18n>, [">= 0.4.0"])
-      gem.add_development_dependency(%q<rspec>, ["~> 2.6.0"])
-      gem.add_development_dependency(%q<yard>, ["~> 0.6.7"])
-      gem.add_development_dependency(%q<rake>)
-    else
-      gem.add_dependency(%q<i18n>, [">= 0.4.0"])
-      gem.add_dependency(%q<rspec>, ["~> 2.6.0"])
-      gem.add_dependency(%q<yard>, ["~> 0.6.7"])
-      gem.add_dependency(%q<rake>)
-    end
-  else
-    gem.add_dependency(%q<i18n>, [">= 0.4.0"])
-    gem.add_dependency(%q<rspec>, ["~> 2.6.0"])
-    gem.add_dependency(%q<yard>, ["~> 0.6.7"])
-    gem.add_dependency(%q<rake>)
-  end
-
-  ignores = File.read(".gitignore").split(/\r?\n/).reject{ |f| f =~ /^(#.+|\s*)$/ }.map {|f| Dir[f] }.flatten
-  gem.files = (Dir['**/*','.gitignore'] - ignores).reject {|f| !File.file?(f) }
-  gem.test_files = (Dir['spec/**/*','features/**/*','.gitignore'] - ignores).reject {|f| !File.file?(f) }
-  gem.executables   = Dir['bin/*'].map { |f| File.basename(f) }
-  gem.require_paths = ['lib']
-end

data/pkg/webmachine-0.2.0/spec/spec_helper.rb

@@ -1,13 +0,0 @@
-$LOAD_PATH << File.expand_path("..", __FILE__)
-$LOAD_PATH << File.expand_path("../../lib", __FILE__)
-
-require 'rubygems'
-require 'webmachine'
-require 'rspec'
-
-RSpec.configure do |config|
-  config.mock_with :rspec
-  config.filter_run :focus => true
-  config.run_all_when_everything_filtered = true
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-end

data/pkg/webmachine-0.2.0/spec/tests.org

@@ -1,57 +0,0 @@
-* 2,2 Basic Rules
-  - HTTP/1.1 header field values can be folded onto multiple lines if
-    the continuation line begins with a space or horizontal tab. All
-    linear white space, including folding, has the same semantics as
-    SP. A recipient MAY replace any linear white space with a single
-    SP before interpreting the field value or forwarding the message
-    downstream.
-  - Many HTTP/1.1 header field values consist of words separated by
-    LWS or special characters. These special characters MUST be in a
-    quoted string to be used within a parameter value (as defined in
-    section 3.6).
-* 3.1 HTTP Version
-  - Note that the major and minor numbers MUST be treated as separate
-    integers and that each MAY be incremented higher than a single
-    digit.
-  - Leading zeros MUST be ignored by recipients and MUST NOT be sent.
-  - An application that sends a request or response message that
-    includes HTTP-Version of "HTTP/1.1" MUST be at least conditionally
-    compliant with this specification.
-  - Applications that are at least conditionally compliant with this
-    specification SHOULD use an HTTP-Version of "HTTP/1.1" in their
-    messages, and MUST do so for any message that is not compatible
-    with HTTP/1.0.
-  - Since the protocol version indicates the protocol capability of
-    the sender, a proxy/gateway MUST NOT send a message with a version
-    indicator which is greater than its actual version. If a higher
-    version request is received, the proxy/gateway MUST either
-    downgrade the request version, or respond with an error, or switch
-    to tunnel behavior.
-  - Due to interoperability problems with HTTP/1.0 proxies discovered
-    since the publication of RFC 2068 [33], caching proxies MUST,
-    gateways MAY, and tunnels MUST NOT upgrade the request to the
-    highest version they support. The proxy/gateway's response to that
-    request MUST be in the same major version as the request.
-* 3.2 URIs
-** General Syntax
-   - Servers MUST be able to handle the URI of any resource they serve.
-   - Servers SHOULD be able to handle URIs of unbounded length if they
-     provide GET-based forms that could generate such URIs.
-   - A server SHOULD return 414 (Request-URI Too Long) status if a URI
-     is longer than the server can handle
-** http URL
-   - If the abs_path is not present in the URL, it MUST be given as
-     "/" when used as a Request-URI for a resource.
-   - If a proxy receives a fully qualified domain name, the proxy MUST
-     NOT change the host name.
-** URI Comparison
-   - When comparing two URIs to decide if they match or not, a client
-     SHOULD use a case-sensitive octet-by-octet comparison of the
-     entire URIs, with these exceptions:
-     - A port that is empty or not given is equivalent to the default
-       port for that URI-reference
-     - Comparisons of host names MUST be case-insensitive
-     - Comparisons of scheme names MUST be case-insensitive
-     - An empty abs_path is equivalent to an abs_path of "/"  
-* 3.3 Date/Time Formats
-  

data/pkg/webmachine-0.2.0/spec/webmachine/configuration_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Configuration do
-  before { Webmachine.configuration = nil }
-  
-  %w{ip port adapter adapter_options}.each do |field|
-    it { should respond_to(field) }
-    it { should respond_to("#{field}=") }
-  end
-
-  it "should yield configuration to the block" do
-    Webmachine.configure do |config|
-      config.should be_kind_of(described_class)
-    end
-  end
-
-  it "should set the global configuration from the yielded instance" do
-    Webmachine.configure do |config|
-      @config = config
-    end
-    @config.should == Webmachine.configuration
-  end
-
-  it "should return the module from the configure call so you can chain it" do
-    Webmachine.configure {|c|}.should == Webmachine
-  end
-end

data/pkg/webmachine-0.2.0/spec/webmachine/decision/conneg_spec.rb

@@ -1,159 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Decision::Conneg do
-  let(:request) { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/"), Webmachine::Headers["accept" => "*/*"], "") }
-  let(:response) { Webmachine::Response.new }
-  let(:resource) do
-    Class.new(Webmachine::Resource) do
-      def to_html; "hello world!"; end
-    end
-  end
-
-  subject do
-    Webmachine::Decision::FSM.new(resource, request, response)
-  end
-
-  context "choosing a media type" do
-    it "should not choose a type when none are provided" do
-      subject.choose_media_type([], "*/*").should be_nil
-    end
-
-    it "should not choose a type when none are acceptable" do
-      subject.choose_media_type(["text/html"], "application/json").should be_nil
-    end
-
-    it "should choose the first acceptable type" do
-      subject.choose_media_type(["text/html", "application/xml"],
-                                "application/xml, text/html, */*").should == "application/xml"
-    end
-
-    it "should choose the type that matches closest when matching subparams" do
-      subject.choose_media_type(["text/html",
-                                 ["text/html", {"charset" => "iso8859-1"}]],
-                                "text/html;charset=iso8859-1, application/xml").
-        should == "text/html;charset=iso8859-1"
-    end
-    
-    it "should choose a type more specific than requested when an exact match is not present" do
-      subject.choose_media_type(["application/json;v=3;foo=bar", "application/json;v=2"],
-                                "text/html, application/json").
-        should == "application/json;v=3;foo=bar"
-    end
-
-
-    it "should choose the preferred type over less-preferred types" do
-      subject.choose_media_type(["text/html", "application/xml"],
-                                "application/xml;q=0.7, text/html, */*").should == "text/html"
-
-    end
-
-    it "should raise an exception when a media-type is improperly formatted" do
-      expect {
-        subject.choose_media_type(["text/html", "application/xml"],
-                                  "bah;")
-      }.to raise_error(Webmachine::MalformedRequest)
-    end
-  end
-
-  context "choosing an encoding" do
-    it "should not set the encoding when none are provided" do
-      subject.choose_encoding({}, "identity, gzip")
-      subject.metadata['Content-Encoding'].should be_nil
-      subject.response.headers['Content-Encoding'].should be_nil
-    end
-
-    it "should not set the Content-Encoding header when it is identity" do
-      subject.choose_encoding({"gzip"=> :encode_gzip, "identity" => :encode_identity}, "identity")
-      subject.metadata['Content-Encoding'].should == 'identity'
-      response.headers['Content-Encoding'].should be_nil
-    end
-
-    it "should choose the first acceptable encoding" do
-      subject.choose_encoding({"gzip" => :encode_gzip}, "identity, gzip")
-      subject.metadata['Content-Encoding'].should == 'gzip'
-      response.headers['Content-Encoding'].should == 'gzip'
-    end
-
-    it "should choose the preferred encoding over less-preferred encodings" do
-      subject.choose_encoding({"gzip" => :encode_gzip, "identity" => :encode_identity}, "gzip, identity;q=0.7")
-      subject.metadata['Content-Encoding'].should == 'gzip'
-      response.headers['Content-Encoding'].should == 'gzip'
-    end
-
-    it "should not set the encoding if none are acceptable" do
-      subject.choose_encoding({"gzip" => :encode_gzip}, "identity")
-      subject.metadata['Content-Encoding'].should be_nil
-      response.headers['Content-Encoding'].should be_nil
-    end
-  end
-
-  context "choosing a charset" do
-    it "should not set the charset when none are provided" do
-      subject.choose_charset([], "ISO-8859-1")
-      subject.metadata['Charset'].should be_nil
-    end
-
-    it "should choose the first acceptable charset" do
-      subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "US-ASCII, UTF-8")
-      subject.metadata['Charset'].should == "US-ASCII"
-    end
-
-    it "should choose the preferred charset over less-preferred charsets" do
-      subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "US-ASCII;q=0.7, UTF-8")
-      subject.metadata['Charset'].should == "UTF-8"
-    end
-
-    it "should not set the charset if none are acceptable" do
-      subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "ISO-8859-1")
-      subject.metadata['Charset'].should be_nil
-    end
-
-    it "should choose a charset case-insensitively" do
-      subject.choose_charset([["UtF-8", :to_utf8],["US-ASCII", :to_ascii]], "iso-8859-1, utf-8")
-      subject.metadata['Charset'].should == "utf-8"
-    end
-  end
-
-  context "choosing a language" do
-    it "should not set the language when none are provided" do
-      subject.choose_language([], "en")
-      subject.metadata['Language'].should be_nil
-    end
-
-    it "should choose the first acceptable language" do
-      subject.choose_language(['en', 'en-US', 'es'], "en-US, es")
-      subject.metadata['Language'].should == "en-US"
-      response.headers['Content-Language'].should == "en-US"
-    end
-
-    it "should choose the preferred language over less-preferred languages" do
-      subject.choose_language(['en', 'en-US', 'es'], "en-US;q=0.6, es")
-      subject.metadata['Language'].should == "es"
-      response.headers['Content-Language'].should == "es"
-    end
-
-    it "should select the first language if all are acceptable" do
-      subject.choose_language(['en', 'fr', 'es'], "*")
-      subject.metadata['Language'].should == "en"
-      response.headers['Content-Language'].should == "en"
-    end
-
-    it "should select the closest acceptable language when an exact match is not available" do
-      subject.choose_language(['en-US', 'es'], "en, fr")
-      subject.metadata['Language'].should == 'en-US'
-      response.headers['Content-Language'].should == 'en-US'
-    end
-
-    it "should not set the language if none are acceptable" do
-      subject.choose_language(['en'], 'es')
-      subject.metadata['Language'].should be_nil
-      response.headers.should_not include('Content-Language')
-    end
-
-    it "should choose a language case-insensitively" do
-      subject.choose_language(['en-US', 'ZH'], 'zh-ch, EN')
-      subject.metadata['Language'].should == 'en-US'
-      response.headers['Content-Language'].should == 'en-US'
-    end
-  end
-end