webmachine 0.1.0

data/spec/webmachine/dispatcher/route_spec.rb

@@ -0,0 +1,109 @@
+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/spec/webmachine/dispatcher_spec.rb

@@ -0,0 +1,34 @@
+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/spec/webmachine/headers_spec.rb

@@ -0,0 +1,19 @@
+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/spec/webmachine/request_spec.rb

@@ -0,0 +1,24 @@
+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/webmachine.gemspec

@@ -0,0 +1,44 @@
+$:.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://seancribbs.github.com/webmachine.rb"
+  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

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: webmachine
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Sean Cribbs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-25 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &2152637280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152637280
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2152636780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2152636780
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &2152636300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.7
+  type: :development
+  prerelease: false
+  version_requirements: *2152636300
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2152635920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2152635920
+description: ! ' 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. '
+email:
+- sean@basho.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- examples/webrick.rb
+- Gemfile
+- Guardfile
+- lib/webmachine/adapters/webrick.rb
+- lib/webmachine/adapters.rb
+- lib/webmachine/decision/conneg.rb
+- lib/webmachine/decision/flow.rb
+- lib/webmachine/decision/fsm.rb
+- lib/webmachine/decision/helpers.rb
+- lib/webmachine/decision.rb
+- lib/webmachine/dispatcher/route.rb
+- lib/webmachine/dispatcher.rb
+- lib/webmachine/errors.rb
+- lib/webmachine/headers.rb
+- lib/webmachine/locale/en.yml
+- lib/webmachine/request.rb
+- lib/webmachine/resource/callbacks.rb
+- lib/webmachine/resource/encodings.rb
+- lib/webmachine/resource.rb
+- lib/webmachine/response.rb
+- lib/webmachine/streaming.rb
+- lib/webmachine/translation.rb
+- lib/webmachine/version.rb
+- lib/webmachine.rb
+- Rakefile
+- README.md
+- spec/spec_helper.rb
+- spec/tests.org
+- spec/webmachine/decision/conneg_spec.rb
+- spec/webmachine/decision/flow_spec.rb
+- spec/webmachine/dispatcher/route_spec.rb
+- spec/webmachine/dispatcher_spec.rb
+- spec/webmachine/headers_spec.rb
+- spec/webmachine/request_spec.rb
+- webmachine.gemspec
+- .gitignore
+homepage: http://seancribbs.github.com/webmachine.rb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: webmachine is a toolkit for building HTTP applications,
+test_files:
+- spec/spec_helper.rb
+- spec/tests.org
+- spec/webmachine/decision/conneg_spec.rb
+- spec/webmachine/decision/flow_spec.rb
+- spec/webmachine/dispatcher/route_spec.rb
+- spec/webmachine/dispatcher_spec.rb
+- spec/webmachine/headers_spec.rb
+- spec/webmachine/request_spec.rb
+- .gitignore