webmachine 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 280847c579eab4ad41bfd4ce4d0471cf56a0c7db
-  data.tar.gz: 521c6386b2202a050ed8dea00b5c3ee2d152a259
+  metadata.gz: 76f443d8e22ccb13b371b7aedfd2d02204653d89
+  data.tar.gz: d2b04ca2adc316e74903f02696bd55ae6bc1a900
 SHA512:
-  metadata.gz: b9e961c7352e6857dddd1f95206d566261d97340f8304fe7f73e021d04a3adf1f47a701d41635bff6c55db65be22561c0ea87f29ddcd6be6751d32a8237d2b20
-  data.tar.gz: 6f865e4318a96693486f4b454a932d8970f22bd6b008a90a41fe62cc92e55af7e346889026fac8bff3d4c072e2eaa7d9371f4f27dc15171f7cf6a25bc2c3599e
+  metadata.gz: ea9cdbfdf582062d7c5eea818816482f99bb75e915625b62263b62936c79b5126c5f046cab13bc72524caf97c1e0cf031551e445b0f10d9d0b0714377e556e7f
+  data.tar.gz: 26575bcdc2c324d42c2af0cb1029654a4c4c92003a17738c12036f55908c97d94f8a461e79f24df3700040c480937568a03f55f9c2c21c1dd40ca1fae2cc980a

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ### HEAD
 
+### 1.4.0 March 20, 2015
+
+* Added RackMapped adapter which allows Webmachine apps to be mounted
+  at a non-root path using Rack::Map.
+  Thanks to [Julian Doherty](https://github.com/madlep) for writing this.
+
 ### 1.3.1 January 15, 2015
 
 * Fixed URI construction, including handling IPv6 addresses, when the

data/README.md

@@ -1,4 +1,4 @@
-# webmachine for Ruby [![travis](https://travis-ci.org/seancribbs/webmachine-ruby.png?branch=master)](http://travis-ci.org/seancribbs/webmachine-ruby)
+# webmachine for Ruby [![Build Status](https://travis-ci.org/seancribbs/webmachine-ruby.svg)](https://travis-ci.org/seancribbs/webmachine-ruby)
 
 webmachine-ruby is a port of
 [Webmachine](https://github.com/basho/webmachine), which is written in

data/documentation/adapters.md

@@ -10,14 +10,16 @@ run on any webserver that provides a Rack interface. It also lets it run on
 In order to be compatible with popular deployment stacks,
 Webmachine has a [Rack](https://github.com/rack/rack) adapter (thanks to Jamis Buck).
 
-Webmachine can be used with Rack middlware features such as Rack::Map and Rack::Cascade as long as:
-
-1. The Webmachine app is mounted at the root directory.
-2. Any requests/responses that are handled by the Webmachine app are not modified by the middleware. The behaviours that are encapsulated in Webmachine assume that no modifications
+Webmachine can be used with Rack middlware features such as Rack::Map and Rack::Cascade as long as any requests/responses that are handled by the Webmachine app are **not** modified by the middleware. The behaviours that are encapsulated in Webmachine assume that no modifications
 are done to requests or response outside of Webmachine.
 
 Keep in mind that Webmachine already supports many things that Rack middleware is used for with other HTTP frameworks (eg. etags, specifying supported/preferred Accept and Content-Types).
 
+The base `Webmachine::Adapters::Rack` class assumes the Webmachine application
+is mounted at the route path `/` (i.e. not using `Rack::Builder#map` or Rails
+`ActionDispatch::Routing::Mapper::Base#mount`). In order to
+map to a subpath, use the `Webmachine::Adapters::RackMapped` adapter instead.
+
 For an example of using Webmachine with Rack middleware, see the [Pact Broker][middleware-example].
 
 See the [Rack Adapter API docs][rack-adapter-api-docs] for more information.

data/lib/webmachine/adapters/rack.rb

@@ -12,9 +12,12 @@ module Webmachine
     # A minimal "shim" adapter to allow Webmachine to interface with Rack. The
     # intention here is to allow Webmachine to run under Rack-compatible
     # web-servers, like unicorn and pow.
+    #
     # The adapter expects your Webmachine application to be mounted at the root path -
     # it will NOT allow you to nest your Webmachine application at an arbitrary path
     # eg. map "/api" { run MyWebmachineAPI }
+    # To use map your Webmachine application at an arbitrary path, use the
+    # `Webmachine::Adapters::RackMapped` subclass instead.
     #
     # To use this adapter, create a config.ru file and populate it like so:
     #
@@ -59,10 +62,7 @@ module Webmachine
         headers = Webmachine::Headers.from_cgi(env)
 
         rack_req = ::Rack::Request.new env
-        request = Webmachine::Request.new(rack_req.request_method,
-                                          rack_req.url,
-                                          headers,
-                                          RequestBody.new(rack_req))
+        request = build_webmachine_request(rack_req, headers)
 
         response = Webmachine::Response.new
         application.dispatcher.dispatch(request, response)
@@ -95,6 +95,26 @@ module Webmachine
         rack_res.finish
       end
 
+      protected
+      def routing_tokens(rack_req)
+        nil # no-op for default, un-mapped rack adapter
+      end
+
+      def base_uri(rack_req)
+        nil # no-op for default, un-mapped rack adapter
+      end
+
+      private
+      def build_webmachine_request(rack_req, headers)
+        Webmachine::Request.new(rack_req.request_method,
+                                rack_req.url,
+                                headers,
+                                RequestBody.new(rack_req),
+                                routing_tokens(rack_req),
+                                base_uri(rack_req)
+                               )
+      end
+
       class RackResponse
         ONE_FIVE = '1.5'.freeze
 
@@ -166,6 +186,5 @@ module Webmachine
         end
       end # class RequestBody
     end # class Rack
-
   end # module Adapters
 end # module Webmachine

data/lib/webmachine/adapters/rack_mapped.rb

@@ -0,0 +1,42 @@
+require 'webmachine/adapters/rack'
+
+module Webmachine
+  module Adapters
+    # Provides the same functionality as the parent Webmachine::Adapters::Rack
+    # adapter, but allows the Webmachine application to be hosted at an
+    # arbitrary path in a parent Rack application (as in Rack `map` or Rails
+    # routing `mount`)
+    #
+    # This functionality is separated out from the parent class to preserve
+    # backward compatibility in the behaviour of the parent Rack adpater.
+    #
+    # To use the adapter in a parent Rack application, map the Webmachine
+    # application as follows in a rackup file or Rack::Builder:
+    #
+    #   map '/foo' do
+    #     run SomeotherRackApp
+    #
+    #     map '/bar' do
+    #       run MyWebmachineApp.adapter
+    #     end
+    #   end
+    class RackMapped < Rack
+
+      protected
+
+      def routing_tokens(rack_req)
+        routing_match = rack_req.path_info.match(Webmachine::Request::ROUTING_PATH_MATCH)
+        routing_path = routing_match ? routing_match[1] : ""
+        routing_path.split(SLASH)
+      end
+
+      def base_uri(rack_req)
+        # rack SCRIPT_NAME env var doesn't end with "/". This causes weird
+        # behavour when URI.join concatenates URI components in
+        # Webmachine::Decision::Flow#n11
+        script_name = rack_req.script_name + SLASH
+        URI.join(rack_req.base_url, script_name)
+      end
+    end # class RackMapped
+  end # module Adapters
+end # module Webmachine

data/lib/webmachine/dispatcher/route.rb

@@ -79,13 +79,11 @@ module Webmachine
         raise ArgumentError, t('not_resource_class', :class => resource.name) unless resource < Resource
       end
 
-      PATH_MATCH = /^\/(.*)/.freeze
-
       # Determines whether the given request matches this route and
       # should be dispatched to the {#resource}.
       # @param [Reqeust] request the request object
       def match?(request)
-        tokens = request.uri.path.match(PATH_MATCH)[1].split(SLASH)
+        tokens = request.routing_tokens
         bind(tokens, {}) && guards.all? { |guard| guard.call(request) }
       end
 
@@ -93,9 +91,9 @@ module Webmachine
       # route, including path bindings.
       # @param [Request] request the request object
       def apply(request)
-        request.disp_path = request.uri.path.match(PATH_MATCH)[1]
+        request.disp_path = request.routing_tokens.join(SLASH)
         request.path_info = @bindings.dup
-        tokens = request.disp_path.split(SLASH)
+        tokens = request.routing_tokens
         depth, trailing = bind(tokens, request.path_info)
         request.path_tokens = trailing || []
       end

data/lib/webmachine/request.rb

@@ -8,10 +8,11 @@ module Webmachine
   # should be instantiated by {Adapters} when a request is received
   class Request
     HTTP_HEADERS_MATCH = /^(?:[a-z0-9])+(?:_[a-z0-9]+)*$/i.freeze
+    ROUTING_PATH_MATCH = /^\/(.*)/.freeze
 
     extend Forwardable
 
-    attr_reader :method, :uri, :headers, :body
+    attr_reader :method, :uri, :headers, :body, :routing_tokens, :base_uri
     attr_accessor :disp_path, :path_info, :path_tokens
 
     # @param [String] method the HTTP request method
@@ -20,9 +21,14 @@ module Webmachine
     # @param [Headers] headers the HTTP request headers
     # @param [String,#to_s,#each,nil] body the entity included in the
     #   request, if present
-    def initialize(method, uri, headers, body)
+    def initialize(method, uri, headers, body, routing_tokens=nil, base_uri=nil)
       @method, @headers, @body = method, headers, body
       @uri = build_uri(uri, headers)
+      @routing_tokens = routing_tokens || @uri.path.match(ROUTING_PATH_MATCH)[1].split(SLASH)
+      @base_uri = base_uri || @uri.dup.tap do |u|
+        u.path = SLASH
+        u.query = nil
+      end
     end
 
     def_delegators :headers, :[]
@@ -53,16 +59,6 @@ module Webmachine
       !(body.nil? || body.empty?)
     end
 
-    # The root URI for the request, ignoring path and query. This is
-    # useful for calculating relative paths to resources.
-    # @return [URI]
-    def base_uri
-      @base_uri ||= uri.dup.tap do |u|
-        u.path = SLASH
-        u.query = nil
-      end
-    end
-
     # Returns a hash of query parameters (they come after the ? in the
     # URI). Note that this does NOT work in the same way as Rails,
     # i.e. it does not support nested arrays and hashes.

data/lib/webmachine/version.rb

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

data/spec/webmachine/adapters/rack_mapped_spec.rb

@@ -0,0 +1,71 @@
+require 'webmachine/adapter'
+require 'webmachine/adapters/rack_mapped'
+require 'spec_helper'
+require 'webmachine/spec/adapter_lint'
+require 'rack/test'
+
+describe Webmachine::Adapters::RackMapped do
+  it_should_behave_like :adapter_lint do
+    it "should set Server header" do
+      response = client.request(Net::HTTP::Get.new("/test"))
+      expect(response["Server"]).to match(/Webmachine/)
+      expect(response["Server"]).to match(/Rack/)
+    end
+  end
+end
+
+describe Webmachine::Adapters::RackMapped do
+  class CreateResource < Webmachine::Resource
+    def allowed_methods
+      ["POST"]
+    end
+
+    def content_types_accepted
+      [["application/json", :from_json]]
+    end
+
+    def content_types_provided
+      [["application/json", :to_json]]
+    end
+
+    def post_is_create?
+      true
+    end
+
+    def create_path
+      "created_path_here/123"
+    end
+
+    def from_json
+      response.body = %{ {"foo": "bar"} }
+    end
+  end
+
+  let(:app) do
+    Rack::Builder.new do
+      map '/some/route' do
+        run(Webmachine::Application.new do |app|
+          app.add_route(["test"], Test::Resource)
+          app.add_route(["create_test"], CreateResource)
+          app.configure do | config |
+            config.adapter = :RackMapped
+          end
+        end.adapter)
+      end
+    end
+  end
+
+  context "using Rack::Test" do
+    include Rack::Test::Methods
+
+    it "provides the full request URI" do
+      rack_response = get "some/route/test", nil, {"HTTP_ACCEPT" => "test/response.request_uri"}
+      expect(rack_response.body).to eq "http://example.org/some/route/test"
+    end
+
+    it "provides LOCATION header using custom base_uri when creating from POST request" do
+      rack_response = post "/some/route/create_test", %{{"foo": "bar"}}, {"HTTP_ACCEPT" => "application/json", "CONTENT_TYPE" => "application/json"}
+      expect(rack_response.headers["Location"]).to eq("http://example.org/some/route/created_path_here/123")
+    end
+  end
+end

data/spec/webmachine/dispatcher/route_spec.rb

@@ -7,7 +7,8 @@ end
 describe Webmachine::Dispatcher::Route do
   let(:method) { "GET" }
   let(:uri) { URI.parse("http://localhost:8080/") }
-  let(:request){ Webmachine::Request.new(method, uri, Webmachine::Headers.new, "") }
+  let(:routing_tokens) { nil }
+  let(:request){ Webmachine::Request.new(method, uri, Webmachine::Headers.new, "", routing_tokens) }
   let(:resource){ Class.new(Webmachine::Resource) }
 
   describe '#apply' do
@@ -16,9 +17,7 @@ describe Webmachine::Dispatcher::Route do
     }
 
     describe 'a path_info fragment' do
-      before do
-        uri.path = '/hello/planet%20earth%20++'
-      end
+      let(:uri) { URI.parse("http://localhost:8080/hello/planet%20earth%20++") }
 
       it 'should decode the value' do
         route.apply(request)
@@ -30,8 +29,10 @@ describe Webmachine::Dispatcher::Route do
   matcher :match_route do |*expected|
     route = Webmachine::Dispatcher::Route.new(expected[0], Class.new(Webmachine::Resource), expected[1] || {})
     match do |actual|
-      request.uri.path = actual if String === actual
-      route.match?(request)
+      uri = URI.parse("http://localhost:8080")
+      uri.path = actual
+      req = Webmachine::Request.new("GET", uri, Webmachine::Headers.new, "", routing_tokens)
+      route.match?(req)
     end
 
     failure_message do |_|
@@ -124,6 +125,18 @@ describe Webmachine::Dispatcher::Route do
         end
       end
     end
+
+    context "with a request with explicitly specified routing tokens" do
+      subject { "/some/route/foo/bar" }
+      let(:routing_tokens) { ["foo", "bar"] }
+      it { is_expected.to match_route(["foo", "bar"]) }
+      it { is_expected.to match_route(["foo", :id]) }
+      it { is_expected.to match_route ['*'] }
+      it { is_expected.to match_route [:*] }
+      it { is_expected.not_to match_route(["some", "route", "foo", "bar"]) }
+      it { is_expected.not_to match_route %w{foo} }
+      it { is_expected.not_to match_route [:id] }
+    end
   end
 
   context "applying bindings" do
@@ -170,7 +183,8 @@ describe Webmachine::Dispatcher::Route do
 
     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) }
+      let(:uri) { URI.parse("http://localhost:8080/foo/bar/baz") }
+      before { subject.apply(request) }
 
       it "should assign the dispatched path as the path past the initial slash" do
         expect(request.disp_path).to eq("foo/bar/baz")

data/spec/webmachine/request_spec.rb

@@ -3,11 +3,13 @@ require 'spec_helper'
 describe Webmachine::Request do
   subject { request }
 
-  let(:uri)         { URI.parse("http://localhost:8080/some/resource") }
-  let(:http_method) { "GET" }
-  let(:headers)     { Webmachine::Headers.new }
-  let(:body)        { "" }
-  let(:request)     { Webmachine::Request.new(http_method, uri, headers, body) }
+  let(:uri)             { URI.parse("http://localhost:8080/some/resource") }
+  let(:http_method)     { "GET" }
+  let(:headers)         { Webmachine::Headers.new }
+  let(:body)            { "" }
+  let(:routing_tokens)  { nil }
+  let(:base_uri)        { nil }
+  let(:request)         { Webmachine::Request.new(http_method, uri, headers, body, routing_tokens, base_uri) }
 
   it "should provide access to the headers via brackets" do
     subject.headers['Accept'] = "*/*"
@@ -30,8 +32,17 @@ describe Webmachine::Request do
     expect(subject.content_md5).to be_nil
   end
 
-  it "should calculate a base URI" do
-    expect(subject.base_uri).to eq(URI.parse("http://localhost:8080/"))
+  context "base_uri" do
+    it "should calculate a base URI" do
+      expect(subject.base_uri).to eq(URI.parse("http://localhost:8080/"))
+    end
+
+    context "when base_uri has been explicitly set" do
+      let(:base_uri) { URI.parse("http://localhost:8080/some_base_uri/here") }
+      it "should use the provided base_uri" do
+        expect(subject.base_uri).to eq(URI.parse("http://localhost:8080/some_base_uri/here"))
+      end
+    end
   end
 
   it "should provide a hash of query parameters" do
@@ -239,4 +250,24 @@ describe Webmachine::Request do
     end
   end
 
+  describe '#routing_tokens' do
+    subject { request.routing_tokens }
+
+    context "haven't been explicitly set" do
+      let(:routing_tokens) { nil }
+      it "extracts the routing tokens from the path portion of the uri" do
+        expect(subject).to eq(["some", "resource"])
+      end
+    end
+
+    context "have been explicitly set" do
+      let(:routing_tokens) { ["foo", "bar"] }
+
+      it "uses the specified routing_tokens" do
+        expect(subject).to eq(["foo", "bar"])
+      end
+    end
+
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: webmachine
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Sean Cribbs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-15 00:00:00.000000000 Z
+date: 2015-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -89,6 +89,7 @@ files:
 - lib/webmachine/adapters/httpkit.rb
 - lib/webmachine/adapters/lazy_request_body.rb
 - lib/webmachine/adapters/rack.rb
+- lib/webmachine/adapters/rack_mapped.rb
 - lib/webmachine/adapters/reel.rb
 - lib/webmachine/adapters/webrick.rb
 - lib/webmachine/application.rb
@@ -147,6 +148,7 @@ files:
 - spec/spec_helper.rb
 - spec/webmachine/adapter_spec.rb
 - spec/webmachine/adapters/httpkit_spec.rb
+- spec/webmachine/adapters/rack_mapped_spec.rb
 - spec/webmachine/adapters/rack_spec.rb
 - spec/webmachine/adapters/reel_spec.rb
 - spec/webmachine/adapters/webrick_spec.rb
@@ -202,6 +204,7 @@ test_files:
 - spec/spec_helper.rb
 - spec/webmachine/adapter_spec.rb
 - spec/webmachine/adapters/httpkit_spec.rb
+- spec/webmachine/adapters/rack_mapped_spec.rb
 - spec/webmachine/adapters/rack_spec.rb
 - spec/webmachine/adapters/reel_spec.rb
 - spec/webmachine/adapters/webrick_spec.rb