webmachine 0.3.0 → 0.4.0

data/lib/webmachine/media_type.rb

@@ -116,5 +116,5 @@ module Webmachine
         other.major == major && other.minor == "*"
       end
     end
-  end
-end
+  end # class MediaType
+end # module Webmachine

data/lib/webmachine/request.rb

@@ -9,6 +9,8 @@ module Webmachine
     attr_reader :method, :uri, :headers, :body
     attr_accessor :disp_path, :path_info, :path_tokens
 
+    STANDARD_HTTP_METHODS = %w[GET HEAD POST PUT DELETE TRACE CONNECT OPTIONS]
+
     # @param [String] method the HTTP request method
     # @param [URI] uri the requested URI, including host, scheme and
     #   port
@@ -55,12 +57,85 @@ module Webmachine
     def query
       unless @query
         @query = {}
-        uri.query.split(/&/).each do |kv|
+        (uri.query || '').split(/&/).each do |kv|
           k, v = CGI.unescape(kv).split(/=/)
           @query[k] = v if k && v
         end
       end
       @query
     end
-  end
-end
+
+    # Is this an HTTPS request?
+    #
+    # @return [Boolean]
+    #   true if this request was made via HTTPS
+    def https?
+      uri.scheme == "https"
+    end
+
+    # Is this a GET request?
+    #
+    # @return [Boolean]
+    #   true if this request was made with the GET method
+    def get?
+      method == "GET"
+    end
+
+    # Is this a HEAD request?
+    #
+    # @return [Boolean]
+    #   true if this request was made with the HEAD method
+    def head?
+      method == "HEAD"
+    end
+
+    # Is this a POST request?
+    #
+    # @return [Boolean]
+    #   true if this request was made with the GET method
+    def post?
+      method == "POST"
+    end
+
+    # Is this a PUT request?
+    #
+    # @return [Boolean]
+    #   true if this request was made with the PUT method
+    def put?
+      method == "PUT"
+    end
+
+    # Is this a DELETE request?
+    #
+    # @return [Boolean]
+    #   true if this request was made with the DELETE method
+    def delete?
+      method == "DELETE"
+    end
+
+    # Is this a TRACE request?
+    #
+    # @return [Boolean]
+    #   true if this request was made with the TRACE method
+    def trace?
+      method == "TRACE"
+    end
+
+    # Is this a CONNECT request?
+    #
+    # @return [Boolean]
+    #   true if this request was made with the CONNECT method
+    def connect?
+      method == "CONNECT"
+    end
+
+    # Is this an OPTIONS request?
+    #
+    # @return [Boolean]
+    #   true if this request was made with the OPTIONS method
+    def options?
+      method == "OPTIONS"
+    end
+
+  end # class Request
+end # module Webmachine

data/lib/webmachine/resource.rb

@@ -45,5 +45,6 @@ module Webmachine
     def charset_nop(x)
       x
     end
-  end
-end
+
+  end # class Resource
+end # module Webmachine

data/lib/webmachine/resource/authentication.rb

@@ -30,6 +30,7 @@ module Webmachine
           %Q[Basic realm="#{realm}"]
         end
       end
-    end
-  end
-end
+
+    end # module Authentication
+  end # class Resource
+end # module Webmachine

data/lib/webmachine/resource/callbacks.rb

@@ -371,6 +371,7 @@ module Webmachine
       def validate_content_checksum
         nil
       end
-    end
-  end
-end
+
+    end # module Callbacks
+  end # class Resource
+end # module Webmachine

data/lib/webmachine/resource/encodings.rb

@@ -31,6 +31,7 @@ module Webmachine
           Zlib::GzipWriter.wrap(StringIO.new(out)){|gz| gz << data }
         end
       end
-    end
-  end
-end
+
+    end # module Encodings
+  end # class Resource
+end # module Webmachine

data/lib/webmachine/response.rb

@@ -46,5 +46,6 @@ module Webmachine
 
     alias :is_redirect? :redirect
     alias :redirect_to :do_redirect
-  end
-end
+
+  end # class Response
+end # module Webmachine

data/lib/webmachine/streaming.rb

@@ -26,7 +26,7 @@ module Webmachine
         yield resource.send(encoder, resource.send(charsetter, block.to_s))
       end
     end
-  end
+  end # class EnumerableEncoder
 
   # Implements a streaming encoder for callable bodies, such as
   # Proc. (essentially futures)
@@ -44,7 +44,7 @@ module Webmachine
     def to_proc
       method(:call).to_proc
     end
-  end
+  end # class CallableEncoder
 
   # Implements a streaming encoder for Fibers with the same API as the
   # EnumerableEncoder. This will resume the Fiber until it terminates
@@ -59,5 +59,5 @@ module Webmachine
         yield resource.send(encoder, resource.send(charsetter, chunk.to_s))
       end
     end
-  end
-end
+  end # class FiberEncoder
+end # module Webmachine

data/lib/webmachine/version.rb

@@ -1,6 +1,6 @@
 module Webmachine
   # Library version
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 
   # String for use in "Server" HTTP response header, which includes
   # the {VERSION}.

data/spec/webmachine/adapter_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Webmachine::Adapter do
+  let(:configuration) { Webmachine::Configuration.default }
+  let(:dispatcher) { Webmachine::Dispatcher.new }
+  let(:adapter) do
+    described_class.new(configuration, dispatcher)
+  end
+
+  describe "#initialize" do
+    it "stores the provided configuration" do
+      adapter.configuration.should eql configuration
+    end
+
+    it "stores the provided dispatcher" do
+      adapter.dispatcher.should eql dispatcher
+    end
+  end
+
+  describe ".run" do
+    it "creates a new adapter and runs it" do
+      adapter = mock(described_class)
+
+      described_class.should_receive(:new).
+        with(configuration, dispatcher).
+        and_return(adapter)
+
+      adapter.should_receive(:run)
+
+      described_class.run(configuration, dispatcher)
+    end
+  end
+
+  describe "#run" do
+    it "raises a NotImplementedError" do
+      lambda { adapter.run }.should raise_exception(NotImplementedError)
+    end
+  end
+
+end

data/spec/webmachine/adapters/mongrel_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+begin
+  describe Webmachine::Adapters::Mongrel do
+    let(:configuration) { Webmachine::Configuration.default }
+    let(:dispatcher) { Webmachine::Dispatcher.new }
+
+    let(:adapter) do
+      described_class.new(configuration, dispatcher)
+    end
+
+    it "inherits from Webmachine::Adapter" do
+      adapter.should be_a_kind_of(Webmachine::Adapter)
+    end
+
+    it "implements #run" do
+      described_class.instance_methods(false).map {|m| m.to_sym }.should include :run
+    end
+  end
+rescue LoadError
+  warn "Platform is #{RUBY_PLATFORM}: skipping mongrel adapter spec."
+end

data/spec/webmachine/adapters/rack_spec.rb

@@ -11,8 +11,6 @@ module Test
 end
 
 describe Webmachine::Adapters::Rack do
-  let(:adapter) { described_class }
-
   let(:env) do
     { "REQUEST_METHOD"    => "GET",
       "SCRIPT_NAME"       => "",
@@ -29,33 +27,61 @@ describe Webmachine::Adapters::Rack do
       "rack.run_once"     => false }
   end
 
+  let(:configuration) { Webmachine::Configuration.new('0.0.0.0', 8080, :Rack, {}) }
+  let(:dispatcher)    { Webmachine::Dispatcher.new }
+  let(:adapter) do
+    described_class.new(configuration, dispatcher)
+  end
+
+  subject { adapter }
+
   before do
-    Webmachine::Dispatcher.reset
-    Webmachine::Dispatcher.add_route ['test'], Test::Resource
+    dispatcher.add_route ['test'], Test::Resource
+  end
+
+  it "inherits from Webmachine::Adapter" do
+    adapter.should be_a_kind_of(Webmachine::Adapter)
+  end
+
+  describe "#run" do
+    before do
+      configuration.adapter_options[:debug] = true
+    end
+
+    it "starts a rack server with the correct options" do
+      Rack::Server.should_receive(:start).with(
+        :app => adapter,
+        :Port => configuration.port,
+        :Host => configuration.ip,
+        :debug => true
+      )
+
+      adapter.run
+    end
   end
 
   it "should proxy request to webmachine" do
-    code, headers, body = adapter.new.call(env)
+    code, headers, body = subject.call(env)
     code.should == 200
     headers["Content-Type"].should == "text/html"
     body.should include "<html><body>testing</body></html>"
   end
 
   it "should set Server header" do
-    code, headers, body = adapter.new.call(env)
+    code, headers, body = subject.call(env)
     headers.should have_key "Server"
   end
 
   it "should handle non-success correctly" do
     env["PATH_INFO"] = "/missing"
-    code, headers, body = adapter.new.call(env)
+    code, headers, body = subject.call(env)
     code.should == 404
     headers["Content-Type"].should == "text/html"
   end
 
   it "should handle empty bodies correctly" do
     env["HTTP_ACCEPT"] = "application/json"
-    code, headers, body = adapter.new.call(env)
+    code, headers, body = subject.call(env)
     code.should == 406
     headers.should_not have_key "Content-Type"
     headers.should_not have_key "Content-Length"

data/spec/webmachine/adapters/webrick_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Webmachine::Adapters::WEBrick do
+  let(:configuration) { Webmachine::Configuration.default }
+  let(:dispatcher) { Webmachine::Dispatcher.new }
+
+  let(:adapter) do
+    described_class.new(configuration, dispatcher)
+  end
+
+  it "inherits from Webmachine::Adapter" do
+    adapter.should be_a_kind_of(Webmachine::Adapter)
+  end
+
+  it "implements #run" do
+    described_class.instance_methods(false).map {|m| m.to_sym }.should include :run
+  end
+end

data/spec/webmachine/application_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Webmachine::Application do
+  let(:application) { described_class.new }
+  let(:test_resource) { Class.new(Webmachine::Resource) }
+
+  it "accepts a Configuration when initialized" do
+    config = Webmachine::Configuration.new('1.1.1.1', 9999, :Mongrel, {})
+    described_class.new(config).configuration.should be(config)
+  end
+
+  it "is yielded into a block provided during initialization" do
+    yielded_app = nil
+    described_class.new do |app|
+      app.should be_kind_of(Webmachine::Application)
+      yielded_app = app
+    end.should be(yielded_app)
+  end
+
+  it "is initialized with the default Configration if none is given" do
+    application.configuration.should eq(Webmachine::Configuration.default)
+  end
+
+  it "returns the receiver from the configure call so you can chain it" do
+    application.configure { |c| }.should equal(application)
+  end
+
+  it "is configurable" do
+    application.configure do |config|
+      config.should be_kind_of(Webmachine::Configuration)
+    end
+  end
+
+  it "is initialized with an empty Dispatcher" do
+    application.dispatcher.routes.should be_empty
+  end
+
+  it "can have routes added" do
+    route = nil
+    resource = test_resource # overcome instance_eval :/
+
+    application.routes.should be_empty
+
+    application.routes do
+      route = add ['*'], resource
+    end
+
+    route.should be_kind_of(Webmachine::Dispatcher::Route)
+    application.routes.should eq([route])
+  end
+
+  describe "#adapter" do
+    let(:adapter_class) { application.adapter_class }
+
+    it "returns an instance of it's adapter class" do
+      application.adapter.should be_an_instance_of(adapter_class)
+    end
+
+    it "is memoized" do
+      application.adapter.should eql application.adapter
+    end
+  end
+
+  it "can be run" do
+    application.adapter.should_receive(:run)
+    application.run
+  end
+
+  it "can be queried about its configured adapter" do
+    expected = Webmachine::Adapters.const_get(application.configuration.adapter)
+    application.adapter_class.should equal(expected)
+  end
+end

data/spec/webmachine/dispatcher/route_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe Webmachine::Dispatcher::Route do
-  let(:request){ Webmachine::Request.new("GET", URI.parse("http://localhost:8098/"), Webmachine::Headers.new, "") }
+  let(:method) { "GET" }
+  let(:uri) { URI.parse("http://localhost:8080/") }
+  let(:request){ Webmachine::Request.new(method, uri, Webmachine::Headers.new, "") }
   let(:resource){ Class.new(Webmachine::Resource) }
 
   matcher :match_route do |*expected|
@@ -37,6 +39,61 @@ describe Webmachine::Dispatcher::Route do
       it { should_not match_route [] }
       it { should_not match_route %w{bar *} }
     end
+
+    context "with a guard on the request method" do
+      let(:uri){ URI.parse("http://localhost:8080/notes") }
+      let(:route) do
+        described_class.new(
+                            ["notes"],
+                            lambda { |request| request.method == "POST" },
+                            resource
+                            )
+      end
+      subject { route }
+
+      context "when guard passes" do
+        let(:method){ "POST" }
+        it { should be_match(request) }
+
+        context "but the path match fails" do
+          let(:uri){ URI.parse("http://localhost:8080/other") }
+          it { should_not be_match(request) }
+        end
+      end
+
+      context "when guard fails" do
+        let(:method) { "GET" }
+        it { should_not be_match(request) }
+      end
+
+      context "when the guard responds to #call" do
+        let(:guard_class) do
+          Class.new do
+            def initialize(method)
+              @method = method
+            end
+
+            def call(request)
+              request.method == @method
+            end
+          end
+        end
+
+        let(:route) do
+          described_class.new(["notes"], guard_class.new("POST"), resource)
+        end
+
+        context "when the guard passes" do
+          let(:method){ "POST" }
+          it { should be_match(request) }
+        end
+
+        context "when the guard fails" do
+          # let(:method){ "GET" }
+          it { should_not be_match(request) }
+        end
+      end
+    end
   end
 
   context "applying bindings" do
@@ -66,7 +123,7 @@ describe Webmachine::Dispatcher::Route do
 
       context "with a splat" do
         subject { described_class.new(['*'], resource) }
-        
+
         it "should assign empty path tokens" do
           request.path_tokens.should == []
         end