http_router 0.5.4 → 0.6.0

data/lib/http_router.rb

@@ -1,243 +1,91 @@
-require 'rack'
 require 'set'
-require 'url_mount'
+require 'rack'
 require 'http_router/node'
-require 'http_router/root'
-require 'http_router/variable'
-require 'http_router/static'
-require 'http_router/glob'
+require 'http_router/request'
+require 'http_router/response'
 require 'http_router/route'
 require 'http_router/path'
+require 'http_router/regex_route'
 require 'http_router/optional_compiler'
-require 'http_router/parts'
-require 'http_router/version'
-require 'http_router/rack'
 
 class HttpRouter
-  # Raised when a Route is not able to be generated.
-  UngeneratableRouteException      = Class.new(RuntimeError)
-  # Raised when a Route is not able to be generated due to a missing parameter.
-  MissingParameterException        = Class.new(RuntimeError)
-  # Raised when a Route is generated that isn't valid.
-  InvalidRouteException            = Class.new(RuntimeError)
-  # Raised when a Route is not able to be generated due to too many parameters being passed in.
-  TooManyParametersException       = Class.new(RuntimeError)
-  # Raised when an already inserted Route has more conditions added.
-  AlreadyCompiledException         = Class.new(RuntimeError)
-  # Raised when an ambiguous Route is added. For example, this will be raised if you attempt to add "/foo(/:bar)(/:baz)".
-  AmbiguousRouteException          = Class.new(RuntimeError)
-  # Raised when a request condition is added that is not recognized.
-  UnsupportedRequestConditionError = Class.new(RuntimeError)
-  # Raised when there is a potential conflict of variable names within your Route.
-  AmbiguousVariableException       = Class.new(RuntimeError)
+  
+  attr_reader :root, :routes, :known_methods, :named_routes
+  attr_accessor :default_app
 
-  attr_reader :named_routes, :routes, :root, :request_methods_specified, :variable_names
-  attr_accessor :url_mount
+  UngeneratableRouteException = Class.new(RuntimeError)
+  InvalidRouteException       = Class.new(RuntimeError)
+  MissingParameterException   = Class.new(RuntimeError)
 
-  # Creates a new HttpRouter.
-  # Can be called with either <tt>HttpRouter.new(proc{|env| ... }, { .. options .. })</tt> or with the first argument omitted.
-  # If there is a proc first, then it's used as the default app in the case of a non-match.
-  # Supported options are
-  # * :default_app -- Default application used if there is a non-match on #call. Defaults to 404 generator.
-  # * :ignore_trailing_slash -- Ignore a trailing / when attempting to match. Defaults to +true+.
-  # * :redirect_trailing_slash -- On trailing /, redirect to the same path without the /. Defaults to +false+.
-  def initialize(*args, &block)
-    default_app, options = args.first.is_a?(Hash) ? [nil, args.first] : [args.first, args[1]]
-    @options                   = options
-    @default_app               = default_app || options && options[:default_app] || proc{|env| ::Rack::Response.new("Not Found", 404).finish }
-    @ignore_trailing_slash     = options && options.key?(:ignore_trailing_slash) ? options[:ignore_trailing_slash] : true
-    @redirect_trailing_slash   = options && options.key?(:redirect_trailing_slash) ? options[:redirect_trailing_slash] : false
-    @init_block                = block
-    @handle_unavailable_route  = Proc.new{ raise UngeneratableRouteException }
+  def initialize(opts = nil, &blk)
     reset!
-    instance_eval(&block) if block
-  end
-
-  # Ignore trailing slash feature enabled? See #initialize for details.
-  def ignore_trailing_slash?
-    @ignore_trailing_slash
-  end
-
-  # Redirect trailing slash feature enabled? See #initialize for details.
-  def redirect_trailing_slash?
-    @redirect_trailing_slash
+    @ignore_trailing_slash = opts && opts.key?(:ignore_trailing_slash) ? opts[:ignore_trailing_slash] : true
+    instance_eval(&blk) if blk
   end
 
-  # Resets the router to a clean state.
-  def reset!
-    @root = Root.new(self)
-    @request_methods_specified = Set.new
-    @routes = []
-    @named_routes = {}
-    @variable_names = Set.new
-  end
-
-  # Assigns the default application.
-  def default(app)
-    @default_app = app
-  end
-
-  # Adds a path to be recognized.
-  #
-  # To assign a part of the path to a specific variable, use :variable_name within the route.
-  # For example, <tt>add('/path/:id')</tt> would match <tt>/path/test</tt>, with the variable <tt>:id</tt> having the value <tt>"test"</tt>.
-  #
-  # You can receive mulitple parts into a single variable by using the glob syntax.
-  # For example, <tt>add('/path/*id')</tt> would match <tt>/path/123/456/789</tt>, with the variable <tt>:id</tt> having the value <tt>["123", "456", "789"]</tt>.
-  #
-  # As well, paths can end with two optional parts, <tt>*</tt> and <tt>/?</tt>. If it ends with a <tt>*</tt>, it will match partially, returning the part of the path unmatched in the PATH_INFO value of the env. The part matched to will be returned in the SCRIPT_NAME. If it ends with <tt>/?</tt>, then a trailing / on the path will be optionally matched for that specific route. As trailing /'s are ignored by default, you probably don't actually want to use this option that frequently.
-  #
-  # Routes can also contain optional parts. There are surrounded with <tt>( )</tt>'s. If you need to match on a bracket in the route itself, you can escape the parentheses with a backslash.
-  #
-  # The second argument, options, is an optional hash that can modify the route in further ways. See HttpRouter::Route#with_options for details. Typically, you want to add further options to the route by calling additional methods on it. See HttpRouter::Route for further details.
-  #
-  # Returns the route object.
-  def add(path, options = nil)
-    add_route route(path.dup).with_options(options)
-  end
-
-  # Adds a route to be recognized. This must be a HttpRouter::Route object. Returns the route just added.
-  def add_route(route)
+  def add(path, opts = {}, &app)
+    route = case path
+    when Regexp
+      RegexRoute.new(self, path, opts)
+    else
+      Route.new(self, path, opts)
+    end
     @routes << route
+    route.to(app) if app
     route
   end
 
-  # Adds a path that only responds to the request method +GET+.
-  #
-  # Returns the route object.
-  def get(path, options = nil)
-    add(path, options).get
+  def add_with_request_method(path, method, opts = {}, &app)
+    route = add(path, opts).send(method.to_sym)
+    route.to(app) if app
+    route
   end
 
-  # Adds a path that only responds to the request method +POST+.
-  #
-  # Returns the route object.
-  def post(path, options = nil)
-    add(path, options).post
+  [:post, :get, :delete, :put, :head].each do |rm|
+    class_eval "def #{rm}(path, opts = {}, &app); add_with_request_method(path, #{rm.inspect}, opts, &app); end", __FILE__, __LINE__
   end
 
-  # Adds a path that only responds to the request method +PUT+.
-  #
-  # Returns the route object.
-  def put(path, options = nil)
-    add(path, options).put
+  def recognize(env)
+    call(env, false)
+  end
+
+  def call(env, perform_call = true)
+    rack_request = Rack::Request.new(env)
+    request = Request.new(rack_request.path_info, rack_request, perform_call)
+    response = catch(:success) { @root[request] }
+    if !response
+      supported_methods = (@known_methods - [env['REQUEST_METHOD']]).select do |m| 
+        test_env = Rack::Request.new(rack_request.env.clone)
+        test_env.env['REQUEST_METHOD'] = m
+        test_request = Request.new(test_env.path_info, test_env, false)
+        catch(:success) { @root[test_request] }
+      end
+      supported_methods.empty? ? @default_app.call(env) : [405, {'Allow' => supported_methods.sort.join(", ")}, []]
+    elsif response
+      response
+    else
+      @default_app.call(env)
+    end
   end
-
-  # Adds a path that only responds to the request method +DELETE+.
-  #
-  # Returns the route object.
-  def delete(path, options = nil)
-    add(path, options).delete
+  
+  def reset!
+    @root = Node.new(self)
+    @default_app = Proc.new{ |env| Rack::Response.new("Your request couldn't be found", 404).finish }
+    @routes = []
+    @named_routes = {}
+    @known_methods = ['GET', "POST", "PUT", "DELETE"]
   end
 
-  # Generate a URL for a specified route. This will accept a list of variable values plus any other variable names named as a hash.
-  # This first value must be either the Route object or the name of the route.
-  #
-  # Example:
-  #   router = HttpRouter.new
-  #   router.add('/:foo.:format).name(:test).compile
-  #   router.url(:test, 123, 'html')
-  #   # ==> "/123.html"
-  #   router.url(:test, 123, :format => 'html')
-  #   # ==> "/123.html"
-  #   router.url(:test, :foo => 123, :format => 'html')
-  #   # ==> "/123.html"
-  #   router.url(:test, :foo => 123, :format => 'html', :fun => 'inthesun')
-  #   # ==> "/123.html?fun=inthesun"
   def url(route, *args)
     case route
     when Symbol then url(@named_routes[route], *args)
     when Route  then route.url(*args)
-    when nil    then @handle_unavailable_route.call(:url, *args)
-    else             
-    end
-  end
-
-  def url_with_params(route, *args)
-    case route
-    when Symbol then url_with_params(@named_routes[route], *args)
-    when Route  then route.url_with_params(*args)
-    when nil    then @handle_unavailable_route.call(:url_with_params, *args)
-    else             
-    end
-  end
-
-  # Rack compatible #call. If matching route is found, and +dest+ value responds to #call, processing will pass to the matched route. Otherwise,
-  # the default application will be called. The router will be available in the env under the key <tt>router</tt>. And parameters matched will
-  # be available under the key <tt>router.params</tt>. The HttpRouter::Response object will be available under the key <tt>router.response</tt> if
-  # a response is available.
-  def call(env)
-    request = ::Rack::Request.new(env)
-    if redirect_trailing_slash? && (request.head? || request.get?) && request.path_info[-1] == ?/
-      response = ::Rack::Response.new
-      response.redirect(request.path_info[0, request.path_info.size - 1], 302)
-      response.finish
-    else
-      @root.call(request) || @default_app.call(request.env)
+    else raise UngeneratableRouteException
     end
   end
 
-  def recognize(env)
-    @root.recognize(env)
-  end
-
-  # Returns a new node
-  def node(*args)
-    Node.new(self, *args)
-  end
-
-  # Returns a new request node
-  def request_node(*args)
-    RequestNode.new(self, *args)
-  end
-
-  def arbitrary_node(*args)
-    ArbitraryNode.new(self, *args)
-  end
-
-  # Returns a new variable
-  def variable(*args)
-    Variable.new(self, *args)
-  end
-
-  # Returns a new glob
-  def glob(*args)
-    Glob.new(self, *args)
-  end
-
-  # Returns a new route
-  def route(*args)
-    Route.new(self, *args)
-  end
-
-  # Creates a deep-copy of the router.
-  def clone(klass = self.class)
-    cloned_router = klass.new(@default_app, @options)
-    @routes.each do |route|
-      new_route = route.clone(cloned_router)
-      cloned_router.add_route(new_route).compile
-      new_route.name(route.named) if route.named
-      if route.dest
-        begin
-          new_route.to route.dest.clone
-        rescue
-          new_route.to route.dest
-        end
-      end
-    end
-    cloned_router
-  end
-
-  def split(path)
-    Parts.new(path)
-  end
-
-  def self.uri_escape!(s)
-    s.to_s.gsub!(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) { "%#{$1.unpack('H2'*$1.size).join('%').upcase}" }
-  end
-
-  def self.uri_unescape!(s)
-    s.to_s.gsub!(/((?:%[0-9a-fA-F]{2})+)/n){ [$1.delete('%')].pack('H*') }
+  def ignore_trailing_slash?
+    @ignore_trailing_slash
   end
 
   def append_querystring(uri, params)

data/lib/http_router/node.rb

@@ -1,265 +1,163 @@
 class HttpRouter
   class Node
-    class Response < Struct.new(:path, :param_values)
-      attr_reader :params
-      def initialize(path, param_values)
-        super
-        if path.splitting_indexes
-          param_values = param_values.dup
-          path.splitting_indexes.each{|i| param_values[i] = param_values[i].split(HttpRouter::Parts::SLASH_RX)}
-        end
-        @params = path.route.default_values ? path.route.default_values.merge(path.hashify_params(param_values)) : path.hashify_params(param_values)
-      end
-    end
+    autoload :Glob,          'http_router/node/glob'
+    autoload :Variable,      'http_router/node/variable'
+    autoload :Regex,         'http_router/node/regex'
+    autoload :SpanningRegex, 'http_router/node/spanning_regex'
+    autoload :GlobRegex,     'http_router/node/glob_regex'
+    autoload :FreeRegex,     'http_router/node/free_regex'
+    autoload :Arbitrary,     'http_router/node/arbitrary'
+    autoload :Request,       'http_router/node/request'
 
-    attr_accessor :value, :variable, :catchall
-    attr_reader :linear, :lookup, :request_node, :arbitrary_node
+    attr_reader :priority, :router
 
     def initialize(router)
       @router = router
-      reset!
     end
 
-    def reset!
-      @linear, @lookup, @catchall = nil, nil, nil
+    def [](request)
+      destination(request, false)
+      unless request.path.empty?
+        linear(request)
+        lookup(request)
+        variable(request)
+        glob(request)
+      end
+      destination(request)
     end
 
-    def add(val)
-      if val.respond_to?(:matches?)
-        if val.matches_with
-          add_to_linear(val)
-        else
-          add_to_catchall(val)
-        end
-      elsif val.is_a?(Regexp)
-        add_to_linear(val)
-      else
-        create_lookup
-        @lookup[val] ||= router.node
-      end
+    def linear(request)
+      @linear && @linear.each{|n| n[request]}
     end
-    
-    def add_to_linear(val)
-      create_linear
-      n = if @linear.assoc(val)
-        @linear.assoc(val).last
-      else
-        new_node = router.node
-        @linear << [val, new_node]
-        new_node
+  
+    def lookup(request)
+      if @lookup && @lookup[request.path.first]
+        request = request.clone
+        @lookup[request.path.shift][request]
       end
-      @linear.sort!{|a, b| b.first.priority <=> a.first.priority }
-      n
     end
-   
-    def add_arbitrary(procs)
-      target = self
-      if procs && !procs.empty?
-        @arbitrary_node ||= router.arbitrary_node
-        @arbitrary_node.create_linear
-        target = router.node
-        @arbitrary_node.linear << [procs, target]
-        if @value
-          @arbitrary_node.catchall = router.node
-          @arbitrary_node.catchall.value = @value
-          @value = nil
-        end
-      elsif @arbitrary_node
-        target = @arbitrary_node.catchall = router.node
-      end
-      target
+  
+    def variable(request)
+      @variable && @variable[request]
     end
-    
-    def add_to_catchall(val)
-      (@catchall ||= router.node).variable = val
-      @catchall
+  
+    def glob(request)
+      @glob && @glob[request]
+    end
+  
+    def request(request)
+      @request && @request[request]
     end
-    
-    def add_request_methods(request_options)
-      raise UnsupportedRequestConditionError if request_options && (request_options.keys & RequestNode::RequestMethods).size != request_options.size
-      current_nodes = [self]
-      RequestNode::RequestMethods.each do |method|
-        if request_options && request_options.key?(method) # so, the request method we care about it ..
-          current_nodes = [@request_node ||= router.request_node] if current_nodes == [self]
-          for current_node_index in (0...current_nodes.size)
-            current_node = current_nodes.at(current_node_index)
-            current_node.request_method = method unless current_node.request_method
-            case RequestNode::RequestMethods.index(method) <=> RequestNode::RequestMethods.index(current_node.request_method)
-            when 0 #use this node
-              Array(request_options[method]).each_with_index do |request_value, index|
-                if request_value.is_a?(Regexp)
-                  new_node = router.request_node
-                  current_nodes[index == 0 ? current_node_index : current_nodes.length] = new_node
-                  current_node.create_linear
-                  current_node.linear << [request_value, new_node]
-                else
-                  router.request_methods_specified << request_value if method == :request_method
-                  current_node.create_lookup
-                  current_nodes[index == 0 ? current_node_index : current_nodes.length] = (current_node.lookup[request_value] ||= router.request_node)
-                end
+  
+    def arbitrary(request)
+      @arbitrary && @arbitrary.each{|n| n[request]}
+    end
+
+    def unescape(val)
+      val.to_s.gsub(/((?:%[0-9a-fA-F]{2})+)/n){ [$1.delete('%')].pack('H*') }
+    end
+
+    def destination(request_obj, match_partially = true)
+      request(request_obj)
+      arbitrary(request_obj)
+      if match_partially or request_obj.path.empty?
+        @destination && @destination.each do |d|
+          if d.route.match_partially? or request_obj.path.empty? or (@router.ignore_trailing_slash? and request_obj.path.size == 1 and request_obj.path.last == '')
+            if request_obj.perform_call
+              env = request_obj.rack_request.dup.env
+              env['router.params'] ||= {}
+              env['router.params'].merge!(d.hashify_params(request_obj.params))
+              matched = if d.route.match_partially?
+                env['PATH_INFO'] = "/#{request_obj.path.join('/')}"
+                env['SCRIPT_NAME'] += request_obj.rack_request.path_info[0, request_obj.rack_request.path_info.size - env['PATH_INFO'].size]
+              else
+                env["PATH_INFO"] = ''
+                env["SCRIPT_NAME"] += request_obj.rack_request.path_info
               end
-            when 1 #this node is farther ahead
-              current_nodes[current_node_index] = (current_node.catchall ||= router.request_node)
-            when -1 #this method is more important than the current node
-              next_node = current_node.dup
-              current_node.reset!
-              current_node.request_method = method
-              current_node.catchall ||= next_node
-              redo
+              throw :success, d.route.dest.call(env)
+            else
+              throw :success, Response.new(request_obj, d)
             end
           end
-          current_nodes.flatten!
-        else
-          current_nodes.map!{|n| n.is_a?(RequestNode) && n.request_method == method ? (n.catchall ||= router.request_node) : n}
         end
       end
-      transplant_value
-      current_nodes
     end
 
-    protected
-    
-    attr_reader :router
-
-    def transplant_value
-      if @value && @request_node
-        target_node = @request_node
-        while target_node.request_method
-          target_node = (target_node.catchall ||= router.request_node)
-        end
-        target_node.value ||= @value
-        @value = nil
-      end
+    def add_variable
+      @variable ||= Variable.new(@router)
     end
-    
-    def escape_val(val)
-      val.is_a?(Array) ? val.each{|v| HttpRouter.uri_unescape!(v)} : HttpRouter.uri_unescape!(val)
-      val
+
+    def add_glob
+      @glob ||= Glob.new(@router)
     end
 
-    def find_on_parts(request, parts, action = :call, params = [])
-      if parts and !parts.empty?
-        find_on_parts(request, nil, :"#{action}_with_trailing_slash", params) if parts.size == 1 and parts.first == ''
-        if @linear
-          dupped_parts, dupped_params = nil, nil
-          response = @linear.find do |(tester, node)|
-            if tester.respond_to?(:matches?) and match = tester.matches?(parts)
-              dupped_parts, dupped_params = parts.dup, params.dup
-              dupped_params << escape_val(tester.consume(match, dupped_parts))
-              node.find_on_parts(request, dupped_parts, action, dupped_params)
-            elsif tester.respond_to?(:match) and match = tester.match(parts.whole_path) and match.begin(0) == 0
-              dupped_parts, dupped_params = router.split(parts.whole_path[match[0].size, parts.whole_path.size]), params.dup
-              node.find_on_parts(request, dupped_parts, action, dupped_params)
-            else
-              nil
+    def add_request(opts)
+      @request ||= Request.new(@router)
+      next_requests = [@request]
+      Request.request_methods.each do |method|
+        next_requests.map! do |next_request|
+          next_request.request_method = method
+          (opts[method].nil? ? [nil] : Array(opts[method])).map do |request_matcher|
+            case request_matcher
+            when nil
+              next_request.add_catchall
+            when String
+              next_request.add_lookup(request_matcher)
+            when Regexp
+              next_request.add_linear(request_matcher)
             end
           end
         end
-        if match = @lookup && @lookup[parts.first]
-          match.find_on_parts(request, parts[1, parts.size - 1], action, params)
-        end
-        if catchall
-          dupped_parts, dupped_params = parts.dup, params.dup
-          dupped_params << escape_val(catchall.variable.consume(nil, dupped_parts))
-          catchall.find_on_parts(request, dupped_parts, action, dupped_params)
-        end
+        next_requests.flatten!
       end
-      request_node.find_on_request_methods(request, parts, action, params) if request_node
-      arbitrary_node.find_on_arbitrary(request, parts, action, params) if arbitrary_node
-      response = process_match(self, parts, params, request, action) if @value
-      nil
+      next_requests
     end
 
-    def process_match(node, parts, params, request, action)
-      env = request.env
-      case action
-      when :call, :call_with_trailing_slash
-        node.value.each do |path|
-          response_struct = Response.new(path, params)
-          previous_params = env['router.params']
-          env['router'] = router
-          env['router.params'] ||= {}
-          env['router.params'].merge!(response_struct.params)
-          env['router.response'] = response_struct
-          env['SCRIPT_NAME'] ||= ''
-          matched = if path.route.partially_match?
-            env['PATH_INFO'] = "#{HttpRouter::Parts::SLASH}#{parts && parts.join(HttpRouter::Parts::SLASH)}"
-            env['SCRIPT_NAME'] += request.path_info[0, request.path_info.size - env['PATH_INFO'].size]
-            true
-          elsif (parts and (action == :call_with_trailing_slash) and (router.ignore_trailing_slash? or (parts.size == 1 and parts.first == ''))) or parts.nil? || parts.empty?
-            env["PATH_INFO"] = ''
-            env["SCRIPT_NAME"] += request.path_info
-            true
-          else
-            false
-          end
-          if matched
-            response = path.route.dest.call(env)
-            env['router.last_repsonse'] = response
-            if response.first != 404 and response.first != 410
-              throw :response, response
-            end
-          end
-        end if node.value
-      when :nocall, :nocall_with_trailing_slash
-        responses = node.value.select do |path|
-          matched = if path.route.partially_match?
-            true
-          elsif (parts and (action == :nocall_with_trailing_slash) and (router.ignore_trailing_slash? or (parts.size == 1 and parts.first == ''))) or parts.nil? || parts.empty?
-            true
-          else
-            false
+    def add_arbitrary(blk, param_names)
+      @arbitrary ||= []
+      @arbitrary << Arbitrary.new(@router, blk, param_names)
+      @arbitrary.last
+    end
+  
+    def add_match(regexp, matching_indicies = [0], priority = 0)
+      @linear ||= []
+      if priority != 0
+        @linear.each_with_index { |n, i|
+          if priority > (n.priority || 0)
+            @linear[i, 0] = Regex.new(@router, regexp, matching_indicies, priority)
+            return @linear[i]
           end
-        end
-        throw :response, responses.map{|r| Response.new(r, params)} unless responses.empty?
-      else
-        raise
+        }
       end
+      @linear << Regex.new(@router, regexp, matching_indicies, priority)
+      @linear.last
     end
 
-    protected
-      def create_linear
-        @linear ||= []
-      end
-
-      def create_lookup
-        @lookup ||= {}
-      end
-  end
-
-  class ArbitraryNode < Node
-    def find_on_arbitrary(request, parts, action, params)
-      next_node = @linear && !@linear.empty? && @linear.find { |(procs, node)| 
-        params_hash = node.value ? node.value.first.hashify_params(params) : {}
-        procs.all?{|p| p.call(request, params_hash)}
-      }
-      if next_node
-        process_match(next_node.last, parts, params, request, action)
-      elsif @catchall
-        process_match(@catchall, parts, params, request, action)
-      elsif @value
-        process_match(self, parts, params, request, action)
-      end
+    def add_spanning_match(regexp, matching_indicies = [0])
+      @linear ||= []
+      @linear << SpanningRegex.new(@router, regexp, matching_indicies)
+      @linear.last
     end
-  end
   
-  class RequestNode < Node
-    RequestMethods = [:request_method, :host, :port, :scheme, :user_agent, :ip, :fullpath, :query_string].freeze
-    attr_accessor :request_method
-    def find_on_request_methods(request, parts, action, params)
-      if @request_method
-        request_value = request.send(request_method)
-        if @linear && !@linear.empty? && match = @linear.find { |(regexp, node)| regexp === request_value }
-          match.last.find_on_request_methods(request, parts, action, params)
-        end
-        @lookup[request_value].find_on_request_methods(request, parts, action, params) if @lookup and @lookup[request_value]
-        @catchall.find_on_request_methods(request, parts, action, params) if @catchall
-      end
-      if @value
-        process_match(self, parts, params, request, action)
-      elsif arbitrary_node
-        arbitrary_node.find_on_arbitrary(request, parts, action, params)
-      end
+    def add_free_match(regexp)
+      @linear ||= []
+      @linear << FreeRegex.new(@router, regexp)
+      @linear.last
+    end
+  
+    def add_destination(route)
+      @destination ||= []
+      @destination << route
+    end
+  
+    def add_lookup(part)
+      @lookup ||= {}
+      @lookup[part] ||= Node.new(@router)
     end
+
+    def join_whole_path(request)
+      request.path.join('/')
+    end
+
   end
-end
+end