http_router 0.5.4 → 0.6.0

data/lib/http_router/node/arbitrary.rb

@@ -0,0 +1,16 @@
+class HttpRouter
+  class Node
+    class Arbitrary < Node
+      def initialize(router, blk, param_names)
+        @router, @blk, @param_names = router, blk, param_names
+      end
+
+      def [](request)
+        request = request.clone
+        request.continue = proc { |state| destination(request) if state }
+        params = @param_names.nil? ? {} : Hash[@param_names.zip(request.params)]
+        @blk.call(request, params)
+      end
+    end
+  end
+end

data/lib/http_router/node/free_regex.rb

@@ -0,0 +1,19 @@
+class HttpRouter
+  class Node
+    class FreeRegex < Node
+      attr_reader :matcher
+      def initialize(router, matcher)
+        @router, @matcher = router, matcher
+      end
+
+      def [](request)
+        whole_path = "/#{join_whole_path(request)}"
+        if match = @matcher.match(whole_path)
+          request = request.clone
+          request.extra_env['router.regex_match'] = match
+          super
+        end
+      end
+    end
+  end
+end

data/lib/http_router/node/glob.rb

@@ -0,0 +1,16 @@
+class HttpRouter
+  class Node
+    class Glob < Node
+      def [](request)
+        request = request.clone
+        request.params << []
+        remaining_parts = request.path.dup
+        until remaining_parts.empty?
+          request.params[-1] << unescape(remaining_parts.shift)
+          request.path = remaining_parts
+          super(request)
+        end
+      end
+    end
+  end
+end

data/lib/http_router/node/glob_regex.rb

@@ -0,0 +1,9 @@
+class HttpRouter
+  class Node
+    class GlobRegex < SpanningRegex
+      def add_params(request)
+        @capturing_indicies.each { |idx| request.params << unescape(match[idx].split('/')) }
+      end
+    end
+  end
+end

data/lib/http_router/node/regex.rb

@@ -0,0 +1,26 @@
+class HttpRouter
+  class Node
+    class Regex < Node
+      alias_method :node_lookup, :[]
+
+      attr_reader :matcher
+
+      def initialize(router, matcher, capturing_indicies, priority = 0)
+        @router, @matcher, @capturing_indicies, @priority = router, matcher, capturing_indicies, priority
+      end
+
+      def [](request)
+        if match = @matcher.match(request.path.first) and match.begin(0).zero?
+          request = request.clone
+          request.path.shift
+          add_params(request, match)
+          super(request)
+        end
+      end
+
+      def add_params(request, match)
+        @capturing_indicies.each { |idx| request.params << unescape(match[idx]) }
+      end
+    end
+  end
+end

data/lib/http_router/node/request.rb

@@ -0,0 +1,44 @@
+class HttpRouter
+  class Node
+    class Request < Node
+      def self.request_methods
+        [:host, :request_method, :scheme, :user_agent]
+      end
+
+      def initialize(router)
+        @router, @linear, @catchall, @lookup = router, [], nil, {}
+      end
+
+      def request_method=(meth)
+        @request_method = meth == :method ? :request_method : meth
+      end
+
+      def add_lookup(val)
+        @lookup[val] ||= Request.new(@router)
+      end
+
+      def add_catchall
+        @catchall ||= Request.new(@router)
+      end
+
+      def add_linear(matcher)
+        next_node = Request.new(@router)
+        @linear << [matcher, next_node]
+        next_node
+      end
+
+      def [](request)
+        matched = false
+        if @request_method
+          val = request.rack_request.send(@request_method.to_sym)
+          @linear.each { |(matcher, node)| node[request] if matcher === val }
+          @lookup[val][request] if @lookup.key?(val)
+          @catchall[request] if @catchall
+          matched = @lookup.key?(val) || !@catchall.nil?
+        else
+          super(request)
+        end
+      end
+    end
+  end
+end

data/lib/http_router/node/spanning_regex.rb

@@ -0,0 +1,16 @@
+class HttpRouter
+  class Node
+    class SpanningRegex < Regex
+      def [](request)
+        whole_path = join_whole_path(request)
+        if match = @matcher.match(whole_path) and match.begin(0).zero?
+          request = request.clone
+          add_params(request, match)
+          remaining_path = whole_path[match[0].size + (whole_path[match[0].size] == ?/ ? 1 : 0), whole_path.size]
+          request.path = remaining_path.split('/')
+          node_lookup(request)
+        end
+      end
+    end
+  end
+end

data/lib/http_router/node/variable.rb

@@ -0,0 +1,11 @@
+class HttpRouter
+  class Node
+    class Variable < Node
+      def [](request)
+        request = request.clone
+        request.params << unescape(request.path.shift)
+        super(request)
+      end
+    end
+  end
+end

data/lib/http_router/optional_compiler.rb

@@ -2,22 +2,14 @@ class HttpRouter
   class OptionalCompiler
     attr_reader :paths
     def initialize(path)
-      @start_index = 0
-      @end_index = 1
-      @paths = [""]
-      @chars = path.split('')
-      while !@chars.empty?
+      @start_index, @end_index = 0, 1
+      @paths, @chars = [""], path.split('')
+      until @chars.empty?
       case @chars.first[0]
-        when ?(
-          @chars.shift and double_paths
-        when ?)
-          @chars.shift and half_paths
+        when ?( then @chars.shift and double_paths
+        when ?) then @chars.shift and half_paths
         when ?\\ 
-          if @chars[1] == ?( || @chars[1] == ?)
-            @chars.shift 
-          else
-            add_to_current_set(@chars.shift)
-          end
+          @chars[1] == ?( || @chars[1] == ?) ? @chars.shift : add_to_current_set(@chars.shift)
           add_to_current_set(@chars.shift)
         else
           add_to_current_set(@chars.shift)
@@ -25,7 +17,8 @@ class HttpRouter
       end
       @paths
     end
-    
+
+    private
     def add_to_current_set(c)
       (@start_index...@end_index).each { |path_index| @paths[path_index] << c }
     end

data/lib/http_router/path.rb

@@ -1,74 +1,61 @@
 class HttpRouter
   class Path
-    attr_reader :parts, :route, :splitting_indexes, :path
-    def initialize(route, path, parts, splitting_indexes)
-      @route, @path, @parts, @splitting_indexes = route, path, parts, splitting_indexes
-      duplicate_variable_names = variable_names.dup.uniq!
-      raise AmbiguousVariableException, "You have duplicate variable name present: #{duplicate_variable_names.join(', ')}" if duplicate_variable_names
-      regex_parts = path.split(/([:\*][a-zA-Z0-9_]+)/)
-      @path_validation_regex, code = '', ''
-      regex_parts.each_with_index{ |part, index|
-        new_part = case part[0]
-        when ?:, ?*
-          if index != 0 && regex_parts[index - 1][-1] == ?\\
+    attr_reader :route, :param_names
+    def initialize(route, path, param_names = [])
+      @route, @path, @param_names, @static = route, path, param_names, param_names.empty?
+      duplicate_param_names = param_names.dup.uniq!
+      raise AmbiguousVariableException, "You have duplicate variable name present: #{duplicate_param_names.join(', ')}" if duplicate_param_names
+      if path.respond_to?(:split)
+        regex_parts = path.split(/([:\*][a-zA-Z0-9_]+)/)
+        @path_validation_regex, code = '', ''
+        regex_parts.each_with_index{ |part, index|
+          new_part = case part[0]
+          when ?:, ?*
+            if index != 0 && regex_parts[index - 1][-1] == ?\\
+              @path_validation_regex << Regexp.quote(part)
+              code << part
+            else
+              @path_validation_regex << (route.matches_with[part[1, part.size].to_sym] || '.*?').to_s
+              code << "\#{args.shift || (options && options.delete(:#{part[1, part.size]})) || raise(MissingParameterException, \"missing parameter :#{part[1, part.size]}\")}"
+            end
+          else
             @path_validation_regex << Regexp.quote(part)
             code << part
-          else
-            @path_validation_regex << (route.matches_with[part[1, part.size].to_sym] || '.*?').to_s
-            code << "\#{args.shift || (options && options.delete(:#{part[1, part.size]})) || raise(MissingParameterException, \"missing parameter :#{part[1, part.size]}\")}"
           end
-        else
-          @path_validation_regex << Regexp.quote(part)
-          code << part
+          new_part
+        }
+        @path_validation_regex = Regexp.new("^#{@path_validation_regex}$")
+        instance_eval "
+        def raw_url(args,options)
+          \"#{code}\"
         end
-        new_part
-      }
-      @path_validation_regex = Regexp.new("^#{@path_validation_regex}$")
-      instance_eval "
-      def raw_url(args,options)
-        \"#{code}\"
+        ", __FILE__, __LINE__
       end
-      "
     end
 
     def hashify_params(params)
-      !static? && params ? variable_names.zip(params).inject({}) { |h, (k,v)| h[k] = v; h } : {}
-    end
-
-    def ===(other_path)
-      return false if @parts.size != other_path.parts.size
-      @parts.each_with_index {|p,i| 
-        return unless compare_parts(p, other_path.parts[i])
-      }
-      true
-    end
-
-    def compare_parts(p1, p2)
-      case p1
-      when Glob     then p2.is_a?(Glob)
-      when Variable then p2.is_a?(Variable)
-      else               p1 == p2
-      end
+      !@static && params ? param_names.zip(params).inject({}) { |h, (k,v)| h[k] = v; h } : {}
     end
 
     def url(args, options)
       path = raw_url(args, options)
       raise InvalidRouteException if path !~ @path_validation_regex
       raise TooManyParametersException unless args.empty?
-      HttpRouter.uri_escape!(path)
+      uri_escape!(path)
       [path, options]
     end
 
-    def static?
-      variables.empty?
+    def original_path
+      @path
     end
 
-    def variables
-      @variables ||= @parts.select{|p| p.is_a?(Variable)}
+    private
+    def raw_url(args,options)
+      raise UngeneratableRouteException
     end
 
-    def variable_names
-      @variable_names ||= variables.map{|v| v.name}
+    def uri_escape!(s)
+      s.to_s.gsub!(/([^:\/?\[\]\-_~\.!\$&'\(\)\*\+,;=@a-zA-Z0-9]+)/n) { "%#{$1.unpack('H2'*$1.size).join('%').upcase}" }
     end
   end
-end
+end

data/lib/http_router/regex_route.rb

@@ -0,0 +1,20 @@
+class HttpRouter
+  class RegexRoute < Route
+    def initialize(router, path, opts = {})
+      @router, @path, @opts = router, path, opts
+    end
+
+    def compile
+      add_non_path_to_tree(@router.root.add_free_match(path), path, [])
+      @compiled = true
+    end
+
+    def match_partially?
+      true
+    end
+
+    def regex?
+      true
+    end
+  end
+end

data/lib/http_router/request.rb

@@ -0,0 +1,26 @@
+class HttpRouter
+  class Request
+    attr_reader :perform_call
+    attr_accessor :path, :params, :rack_request, :extra_env, :continue
+    alias_method :rack, :rack_request
+    def initialize(path, rack_request, perform_call)
+      @rack_request, @perform_call = rack_request, perform_call
+      @path = (path[0] == ?/ ? path[1, path.size] : path).split(/\//)
+      @path << '' if path.size > 1 && path[-1] == ?/
+      @extra_env = {}
+      @params = []
+    end
+
+    def to_s
+      "request path, #{path.inspect}"
+    end
+    
+    def clone
+      dup_obj = super
+      dup_obj.path = path.dup
+      dup_obj.params = params.dup
+      dup_obj.extra_env = extra_env.dup
+      dup_obj
+    end
+  end
+end

data/lib/http_router/response.rb

@@ -0,0 +1,13 @@
+class HttpRouter
+  class Response < Struct.new(:request, :path)
+    attr_reader :params
+    def initialize(request, path)
+      super(request, path)
+      @params = path.hashify_params(request.params)
+    end
+
+    def param_values
+      request.params
+    end
+  end
+end

data/lib/http_router/route.rb

@@ -1,238 +1,84 @@
-require 'strscan'
-
 class HttpRouter
   class Route
-    attr_reader :dest, :paths, :path, :matches_with, :original_path, :regex
-    attr_accessor :trailing_slash_ignore, :partially_match, :default_values
+    attr_reader :default_values, :matches_with, :router, :path, :conditions
 
-    def initialize(router, path)
+    def initialize(router, path, opts = {})
       @router = router
-      @matches_with = {}
-      @arbitrary = []
-      @conditions =  {}
-      @default_values = {}
-      case path
-      when Regexp
-        @regex = path
-        path = '/*'
-        match_path(@regex)
-      end
+      @original_path = path
       @path = path
-      @original_path = path.dup
-      path[0,0] = '/' unless path[0] == ?/
-      @partially_match = extract_partial_match(path)
-      @trailing_slash_ignore = extract_trailing_slash(path)
-    end
-
-    def method_missing(method, *args, &block)
-      if RequestNode::RequestMethods.include?(method)
-        condition(method => args)
-      else
-        super
+      @opts = opts
+      @arbitrary = opts[:arbitrary] || opts[:__arbitrary__]
+      @conditions = opts[:conditions] || opts[:__conditions__] || {}
+      name(opts.delete(:name)) if opts.key?(:name)
+      @matches_with = {}
+      @default_values = opts[:default_values] || {}
+      if @original_path[-1] == ?*
+        @match_partially = true
+        path.slice!(-1)
       end
+      @paths = OptionalCompiler.new(path).paths
     end
 
-    def regex?
-      !@regex.nil?
-    end
-
-    def to_s
-      "#{@original_path} conditions: #{@conditions.inspect} default_values: #{@default_values.inspect} name: #{named.inspect}"
-    end
-
-    # Returns the options used to create this route.
     def as_options
       {:matching => @matches_with, :conditions => @conditions, :default_values => @default_values, :name => @name, :partial => @partially_match, :arbitrary => @arbitrary}
     end
 
-    # Creates a deep uncompiled copy of this route.
-    def clone(new_router)
-      Route.new(new_router, @original_path.dup).with_options(as_options)
-    end
-
-    # Uses an option hash to apply conditions to a Route.
-    # The following keys are supported.
-    # *name -- Maps to #name method.
-    # *matching -- Maps to #matching method.
-    # *conditions -- Maps to #conditions method.
-    # *default_value -- Maps to #default_value method.
-    def with_options(options)
-      if options
-        name(options.delete(:name))                               if options[:name]
-        matching(options.delete(:matching))                       if options[:matching]
-        condition(options.delete(:conditions))                    if options[:conditions]
-        default(options.delete(:default_values))                  if options[:default_values]
-        partial(options.delete(:partial))                         if options[:partial]
-        Array(options.delete(:arbitrary)).each{|a| arbitrary(&a)} if options[:arbitrary]
-        matching(options)
-      end
-      self
-    end
-
-    # Sets the name of the route
-    # Returns +self+.
-    def name(name)
-      @name = name
-      router.named_routes[@name] = self if @name && compiled?
+    def partial(match_partially = true)
+      @match_partially = match_partially
       self
     end
 
-    # Sets a default value for the route
-    # Returns +self+.
-    #
-    # Example
-    #   router = HttpRouter.new
-    #   router.add("/:test").default(:test => 'foo').name(:test).compile
-    #   router.url(:test)
-    #   # ==> "/foo"
-    #   router.url(:test, 'override')
-    #   # ==> "/override"
-    def default(v)
-      @default_values.merge!(v)
-      self
-    end
-
-    # Causes this route to recognize the GET request method. Returns +self+.
-    def get
-      request_method('GET')
-    end
-
-    # Causes this route to recognize the POST request method. Returns +self+.
-    def post
-      request_method('POST')
+    def match_partially?
+      @match_partially
     end
 
-    # Causes this route to recognize the HEAD request method. Returns +self+.
-    def head
-      request_method('HEAD')
+    def dest
+      @app
     end
 
-    # Causes this route to recognize the PUT request method. Returns +self+.
-    def put
-      request_method('PUT')
+    def regex?
+      false
     end
 
-    # Causes this route to recognize the DELETE request method. Returns +self+.
-    def delete
-      request_method('DELETE')
+    def to(dest = nil, &dest2)
+      @app = dest || dest2
+      compile
+      self
     end
 
-    # Sets a request condition for the route
-    # Returns +self+.
-    #
-    # Example
-    #   router = HttpRouter.new
-    #   router.add("/:test").condition(:host => 'www.example.org').name(:test).compile
-    def condition(conditions)
-      guard_compiled
-      conditions.each do |k,v|
-        @conditions.key?(k) ?
-          @conditions[k] << v :
-          @conditions[k] = Array(v)
-        @conditions[k].flatten!
-      end
-      self
+    def compiled?
+      @compiled
     end
-    alias_method :conditions, :condition
 
-    # Sets a regex matcher for a variable
-    # Returns +self+.
-    #
-    # Example
-    #   router = HttpRouter.new
-    #   router.add("/:test").matching(:test => /\d+/).name(:test).compile
-    def matching(match)
-      guard_compiled
-      match.each do |var_name, matchers|
-        matchers = Array(matchers)
-        matchers.each do |m|
-          @matches_with.key?(var_name) ? raise : @matches_with[var_name] = m
-        end
-      end
+    def name(n)
+      @name = n
+      @router.named_routes[n] = self
       self
     end
 
-    # Returns the current route's name.
-    def named
-      @name
+    def request_method(m)
+      ((@conditions ||= {})[:request_method] ||= []) << m; self
     end
 
-    # Sets the destination of the route. Receives either a block, or a proc.
-    # Returns +self+.
-    #
-    # Example
-    #   router = HttpRouter.new
-    #   router.add("/:test").matching(:test => /\d+/).name(:test).to(proc{ |env| Rack::Response.new("hi there").finish })
-    # Or
-    #   router.add("/:test").matching(:test => /\d+/).name(:test).to { |env| Rack::Response.new("hi there").finish }
-    def to(dest = nil, &block)
-      compile
-      @dest = dest || block
-      if @dest.respond_to?(:url_mount=)
-        urlmount = UrlMount.new(@original_path, @default_values)
-        urlmount.url_mount = router.url_mount if router.url_mount
-        @dest.url_mount = urlmount
-      end
-      self
+    def host(host)
+      ((@conditions ||= {})[:host] ||= []) << host; self
     end
 
-    # Sets partial matching on this route. Defaults to +true+. Returns +self+.
-    def partial(match = true)
-      @partially_match = match
-      self
+    def scheme(scheme)
+      ((@conditions ||= {})[:scheme] ||= []) << scheme; self
     end
 
-    # Convenient regexp matching on an entire path. Returns +self+
-    def match_path(matcher)
-      arbitrary{|env, params, dest|
-        match = matcher.match(env.path_info)
-        if !match.nil? and match.begin(0) == 0 and match[0].size == env.path_info.size
-          env['router.regex_match'] = match
-          true
-        else
-          false
-        end
-      }
+    def user_agent(user_agent)
+      ((@conditions ||= {})[:user_agent] ||= []) << user_agent; self
     end
 
-    # Adds an arbitrary proc matcher to a Route. Receives either a block, or a proc. The proc will receive a Rack::Request object, a Hash of the params, and the destination for this route. The proc must return true if the Route is matched. Returns +self+.
-    def arbitrary(proc = nil, &block)
-      guard_compiled
-      @arbitrary << (proc || block)
+    def matching(matchers)
+      @opts.merge!(matchers)
       self
     end
 
-    # Compile state for route. Returns +true+ or +false+.
-    def compiled?
-      !@paths.nil?
-    end
-
-    # Compiles the route and inserts it into the tree. This is called automatically when you add a destination via #to to the route. Until a route
-    # is compiled, it will not be recognized.
-    def compile
-      if @paths.nil?
-        router.named_routes[@name] = self if @name
-        @paths = compile_paths
-        @paths.each_with_index do |p1, i|
-          @paths[i+1, @paths.size].each do |p2|
-            raise AmbiguousRouteException if p1 === p2
-          end
-        end
-        @paths.each do |path|
-          current_node = router.root.add_path(path)
-          working_set = current_node.add_request_methods(@conditions)
-          working_set.map!{|node| node.add_arbitrary(@arbitrary)}
-          working_set.each do |current_node|
-            case current_node.value
-            when nil
-              current_node.value = [path]
-            else
-              current_node.value << path
-            end
-          end
-          path.variable_names.each{|vn| router.variable_names << vn} unless path.static?
-        end
-      end
+    def default(defaults)
+      (@default_values ||= {}).merge!(defaults)
       self
     end
 
@@ -253,25 +99,31 @@ class HttpRouter
       if File.directory?(root)
         partial.to ::Rack::File.new(root)
       else
-        to proc{|env| env['PATH_INFO'] = File.basename(root); ::Rack::File.new(File.dirname(root)).call(env)}
+        to {|env| env['PATH_INFO'] = File.basename(root); ::Rack::File.new(File.dirname(root)).call(env) }
       end
       self
     end
 
-    # The current state of trailing / ignoring on this route. Returns +true+ or +false+.
-    def trailing_slash_ignore?
-      @trailing_slash_ignore
+    def post;   request_method('POST');   end
+    def get;    request_method('GET');    end
+    def put;    request_method('PUT');    end
+    def delete; request_method('DELETE'); end
+    def head;   request_method('HEAD');   end
+
+    def arbitrary(blk = nil, &blk2)
+      arbitrary_with_continue { |req, params|
+        req.continue[(blk || blk2)[req, params]]
+      }
     end
 
-    # The current state of partial matching on this route. Returns +true+ or +false+.
-    def partially_match?
-      @partially_match
+    def arbitrary_with_continue(blk = nil, &blk2)
+      (@arbitrary ||= []) << (blk || blk2)
+      self
     end
 
-    # Generates a URL for this route. See HttpRouter#url for how the arguments for this are structured.
     def url(*args)
       result, extra_params = url_with_params(*args)
-      router.append_querystring(result, extra_params)
+      @router.append_querystring(result, extra_params)
     end
 
     def url_with_params(*args)
@@ -285,8 +137,9 @@ class HttpRouter
       end
       raise UngeneratableRouteException unless path
       result, params = path.url(args, options)
-      mount_point = router.url_mount && router.url_mount.url(options)
-      mount_point ? [File.join(mount_point, result), params] : [result, params]
+      #mount_point = router.url_mount && router.url_mount.url(options)
+      #mount_point ? [File.join(mount_point, result), params] : [result, params]
+      [result, params]
     end
 
     def significant_variable_names
@@ -301,13 +154,13 @@ class HttpRouter
           significant_keys = other_hash && significant_variable_names & other_hash.keys
           @paths.find { |path|
             var_count = significant_keys ? params.size + significant_keys.size : params.size
-            path.variables.size == var_count
+            path.param_names.size == var_count
           }
         else
           @paths.reverse_each do |path|
             if params && !params.empty?
-              return path if (path.variable_names & params.keys).size == path.variable_names.size
-            elsif path.variable_names.empty?
+              return path if (path.param_names & params.keys).size == path.param_names.size
+            elsif path.param_names.empty?
               return path
             end
           end
@@ -316,108 +169,77 @@ class HttpRouter
       end
     end
 
-    private
-
-    attr_reader :router
-
-    def extract_partial_match(path)
-      path[-1] == ?* && path.slice!(-1)
-    end
-
-    def extract_trailing_slash(path)
-      path[-2, 2] == '/?' && path.slice!(-2, 2)
+    def named
+      @name
     end
 
-    def anonymous_variable(pos)
-      "$#{pos}".to_sym
+    def to_s
+      "#<HttpRouter:Route #{object_id} @original_path=#{@original_path.inspect} @conditions=#{@conditions.inspect} @arbitrary=#{@arbitrary.inspect}>"
     end
 
-    def compile_paths
-      paths = HttpRouter::OptionalCompiler.new(@path).paths
-      paths.map do |path|
-        splitting_indexes = []
-        variable_position = 0
-        counter = 0
-        original_path = path.dup
-        split_path = router.split(path)
-        position = 0
-        new_path = split_path.map do |part|
-          processed_parts = case part
-          when /^:([a-zA-Z_0-9]*)$/
-            v_name = $1.empty? ? anonymous_variable(counter += 1) : $1.to_sym
-            router.variable(v_name, @matches_with[v_name])
-          when /^\*([a-zA-Z_0-9]*)$/
-            if position != split_path.size - 1
-              v_name = $1.empty? ? anonymous_variable(counter += 1) : $1.to_sym
-              splitting_indexes << variable_position
-              remaining_path_parts = split_path[position + 1, split_path.size]
-              look_ahead_variable = remaining_path_parts.find{|p| p[0] == ?: || p[0] == ?*}
-              remaining_matcher = split_path[position + 1, look_ahead_variable ? remaining_path_parts.index(look_ahead_variable) : split_path.size].join('/')
-              remaining_path_parts.index(look_ahead_variable) if look_ahead_variable
-              router.variable(v_name, /^(#{@matches_with[v_name] || '[^\/]*?'}\/)+(?=#{Regexp.quote(remaining_matcher)})/)
+    private
+    def compile
+      return if @compiled
+      @paths.map! do |path|
+        param_names = []
+        node = @router.root
+        path.split(/\//).each do |part|
+          next if part == ''
+          parts = part.scan(/\\.|[:*][a-z0-9_]+|[^:*\\]+/)
+          if parts.size == 1
+            name = part[1, part.size]
+            node = case parts[0][0]
+            when ?\\
+              node.add_lookup(parts[0][1].chr)
+            when ?:
+              param_names << name.to_sym
+              matches_with[name.to_sym] = @opts[name.to_sym]
+              @opts[name.to_sym] ? node.add_spanning_match(@opts.delete(name.to_sym)) : node.add_variable
+            when ?*
+              param_names << name.to_sym
+              matches_with[name.to_sym] = @opts[name.to_sym]
+              @opts[name.to_sym] ? node.add_spanning_match(@opts.delete(name.to_sym)) : node.add_glob
             else
-              v_name = $1.empty? ? anonymous_variable(counter += 1) : $1.to_sym
-              router.glob(v_name, @matches_with[v_name])
+              node.add_lookup(parts[0])
             end
           else
-            generate_interstitial_parts(part)
+            captures = 0
+            priority = 0
+            regex = parts.inject('') do |reg, part|
+              reg << case part[0]
+              when ?\\
+                Regexp.quote(part[1].chr)
+              when ?:
+                captures += 1
+                name = part[1, part.size].to_sym
+                param_names << name
+                matches_with[name] = @opts[name]
+                "(#{(@opts[name] || '.*?')})"
+              else
+                priority += part.size
+                Regexp.quote(part)
+              end
+            end
+            capturing_indicies = []
+            captures.times {|i| capturing_indicies << i + 1}
+            node = node.add_match(Regexp.new("#{regex}$"), capturing_indicies, priority)
           end
-          variable_position += Array(processed_parts).select{|part| part.is_a?(Variable)}.size
-          position += 1
-          processed_parts
         end
-        new_path.flatten!
-        Path.new(self, original_path, new_path, splitting_indexes.empty? ? nil : splitting_indexes)
+        add_non_path_to_tree(node, path, param_names)
       end
+      @compiled = true
     end
 
-    def generate_interstitial_parts(part)
-      part_segments = []
-      scanner = StringScanner.new(part)
-      while !scanner.eos?
-        if scanner.scan(/\\[:\*]/)
-          part_segments << [:static, ''] if part_segments.last.nil? or part_segments.last.first == :variable
-          part_segments.last.last << scanner.matched[-1].chr
-        elsif scanner.scan(/\\/)
-          # do nothing
-        elsif scanner.scan(/:[a-zA_Z0-9_]+/)
-          part_segments << [:variable, scanner.matched]
-        elsif scanner.scan(/./)
-          part_segments << [:static, ''] if part_segments.last.nil? or part_segments.last.first == :variable
-          part_segments.last.last << scanner.matched
-        end
-      end
-      priority = 0
-      if part_segments.size > 1
-        index = 0
-        segs = part_segments.map do |(type, seg)|
-          new_seg = if type == :variable
-            next_index = index + 1
-            v_name = seg[1, seg.size].to_sym
-            matcher = @matches_with[v_name]
-            scan_regex = if next_index == part_segments.size
-              matcher || /^[^\/]+/
-            else
-              /^#{matcher || '[^\/]+?'}(?=#{Regexp.quote(part_segments[next_index].last)})/
-            end
-            router.variable(v_name, scan_regex)
-          else
-            priority += seg.size
-            Static.new("^#{Regexp.quote(seg)}")
-          end
-          index += 1
-          new_seg
-        end
-        segs.each {|seg| seg.priority = priority}
-        segs
+    def add_non_path_to_tree(node, path, names)
+      nodes = if @conditions && !@conditions.empty?
+        node.add_request(@conditions)
       else
-        [part_segments.last.last]
+        [node]
       end
+      @arbitrary.each{|a| nodes.map!{|n| n.add_arbitrary(a, names)} } if @arbitrary
+      path_obj = Path.new(self, path, names)
+      nodes.each{|n| n.add_destination(path_obj)}
+      path_obj
     end
-
-    def guard_compiled
-      raise AlreadyCompiledException if compiled?
-    end
-
   end
-end
+end