Store routing tokens on request. Use them for routing match tests

This introduces a `routing_tokens` attribute on `Webmachine::Request`,
and uses it to lazily instantiate the tokens used by
`Webmachine::Dispatcher::Route#match?`.

This is to allow requests to optionally override the tokens generated
by splitting the uri path. This is useful if webmachine isn't hosted at
the root path of the uri (as when rack map is used).

This SHOULD also give a performance increase for request routing, as
previously the uri was matched against a regex for every routing test,
and then again when the route was applied after it matched. With this
approach, the regex is run on the uri once only and then memomized in
the request. (note - SHOULD be faster... haven't actually benchmarked
it)

Author: madlep

lib/webmachine/dispatcher/route.rb

@@ -79,23 +79,21 @@ def initialize(path_spec, *args)
         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
 
       # Decorates the request with information about the dispatch
       # 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

lib/webmachine/request.rb

@@ -13,6 +13,7 @@ class Request
 
     attr_reader :method, :uri, :headers, :body
     attr_accessor :disp_path, :path_info, :path_tokens
+    attr_writer :routing_tokens
 
     # @param [String] method the HTTP request method
     # @param [URI] uri the requested URI, including host, scheme and
@@ -164,6 +165,12 @@ def options?
       method == OPTIONS_METHOD
     end
 
+    ROUTING_PATH_MATCH = /^\/(.*)/.freeze
+
+    def routing_tokens
+      @routing_tokens ||= uri.path.match(ROUTING_PATH_MATCH)[1].split(SLASH)
+    end
+
     private
 
     IPV6_MATCH = /\A\[(?<address> .* )\]:(?<port> \d+ )\z/x.freeze  # string like "[::1]:80"

spec/webmachine/dispatcher/route_spec.rb

@@ -30,7 +30,13 @@ def warn(*msgs); end # silence warnings for tests
   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
+      case actual
+      when String
+        request.uri.path = actual if String === actual
+      when Array
+        request.uri.path = "/some/route/" + actual.join("/")
+        request.routing_tokens = actual
+      end
       route.match?(request)
     end
 
@@ -124,6 +130,17 @@ def call(request)
         end
       end
     end
+
+    context "with a request with explicitly specified routing tokens" do
+      subject { ["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

spec/webmachine/request_spec.rb

@@ -239,4 +239,23 @@ def body; block_given? ? yield(@body) : @body; end
     end
   end
 
+  describe '#routing_tokens' do
+    subject { request.routing_tokens }
+
+    context "haven't be explicitly set" do
+      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
+      before { request.routing_tokens = ["foo", "bar"] }
+
+      it "uses the specified routing_tokens" do
+        expect(subject).to eq(["foo", "bar"])
+      end
+    end
+
+  end
+
 end