http_router 0.0.1 → 0.1.0

data/README.rdoc

@@ -2,7 +2,11 @@
 
 == Introduction
  
-When I wrote Usher, I made a few compromised in design that I wasn't totally happy with. More and more features got added to it, and eventually, it became harder to maintain. I took a few moments to work in Node.js, and wrote a router there called Sherpa, which I was happier with. But I felt that by losing more abstraction, and tackling just the problem of HTTP routing, I could come up with something even better.
+When I wrote Usher, I made a few compromises in design that I wasn't totally happy with. More and more features got added to it, and eventually, it became harder to maintain. I took a few moments to work in Node.js, and wrote a router there called Sherpa, which I was happier with. But I felt that by losing more abstraction, and tackling just the problem of HTTP routing, I could come up with something even better.
+
+== Warning
+
+This is very new code. Lots of stuff probably doesn't work right. I will likely never support all the features I had in Usher. Documentation is super-sparse.
 
 == Features
 
@@ -38,14 +42,16 @@ e.g.
   
   r = HttpRouter.new
   r.add('/test/:variable(.:format)').name(:my_test_path).to {|env| [200, {}, "Hey dude #{env['router.params'][:variable]}"]}
-  r.add('/test').redirect_to("http://www.google.com")
-  r.add('/static').serves_static_from('/my_file_system')
+  r.add('/test').redirect("http://www.google.com/")
+  r.add('/static').static('/my_file_system')
   
-As well, you can support regex matching and request conditions. To add a regex match, use <tt>:matches_with => { :id => /\d+/ }</tt>.
-To match on a request condition you can use <tt>:conditions => {:request_method => %w(POST HEAD)}</tt>.
+As well, you can support regex matching and request conditions. To add a regex match, use <tt>matching(:id => /\d+/)</tt>.
+To match on a request condition you can use <tt>condition(:request_method => %w(POST HEAD))</tt> or more succinctly <tt>request_method('POST', 'HEAD')</tt>.
 
 There are convenience methods HttpRouter#get, HttpRouter#post, etc for each request method.
 
+Routes will not be recognized unless <tt>#to</tt> has been called on it.
+
 === <tt>#url(name or route, *args)</tt>
 
 Generates a route. The args can either be a hash, a list, or a mix of both.

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/lib/http_router/node.rb

@@ -1,7 +1,7 @@
 class HttpRouter
   class Node
-    attr_accessor :value, :variable, :catchall, :request_node
-    attr_reader :linear, :lookup
+    attr_accessor :value, :variable, :catchall
+    attr_reader :linear, :lookup, :request_node, :extension_node
 
     def initialize
       reset!
@@ -32,71 +32,117 @@ class HttpRouter
       end
     end
     
+    def add_extension(ext)
+      @extension_node ||= Node.new
+      @extension_node.add(ext)
+    end
+    
     def add_request_methods(options)
-      if options && options[:conditions]
-        current_nodes = [@request_node ||= RequestNode.new]
-        request_options = options[:conditions]
-        RequestNode::RequestMethods.each do |method|
-          current_nodes.each_with_index do |current_node, current_node_index|
-            if request_options[method]  #we care about the method
-              if current_node  # and we have to pay attention to what currently is there.
-                unless current_node.request_method
-                  current_node.request_method = method
-                end
-              
-                case RequestNode::RequestMethods.index(method) <=> RequestNode::RequestMethods.index(current_node.request_method)
-                when 0 #use this node
-                  if request_options[method].is_a?(Regexp)
-                    current_node = RequestNode.new
-                    current_node.linear << [request_options[method], current_node]
-                  elsif request_options[method].is_a?(Array)
-                    current_nodes[current_node_index] = request_options[method].map{|val| current_node.lookup[val] ||= RequestNode.new}
-                  else
-                    current_nodes[current_node_index] = (current_node.lookup[request_options[method]] ||= RequestNode.new)
-                  end
-                when 1 #this node is farther ahead
-                  current_nodes[current_node_index] = (current_node.catchall ||= RequestNode.new)
-                  redo
-                when -1 #this method is more important than the current node
-                  new_node = RequestNode.new
-                  new_node.request_method = method
-                  new_node.catchall = current_node
-                  current_nodes[current_node_index] = new_node
-                  redo
+      if !options.empty?
+        generate_request_method_tree(options)
+      elsif @request_node
+        current_node = @request_node
+        while current_node.request_method
+          current_node = (current_node.catchall ||= RequestNode.new)
+        end
+        [current_node]
+      else
+        [self]
+      end
+    end
+    
+    protected
+
+    def transplant_value
+      if @value
+        target_node = @request_node
+        while target_node.request_method
+          target_node = (target_node.catchall ||= RequestNode.new)
+        end
+        target_node.value = @value
+        @value = nil
+      end
+    end
+    
+    def generate_request_method_tree(request_options)
+      raise if (request_options.keys & RequestNode::RequestMethods).size != request_options.size
+      
+      
+      current_nodes = [@request_node ||= RequestNode.new]
+      RequestNode::RequestMethods.each do |method|
+        current_nodes.each_with_index do |current_node, current_node_index|
+          if request_options[method]  #we care about the method
+            if current_node  # and we have to pay attention to what currently is there.
+              unless current_node.request_method
+                current_node.request_method = method
+              end
+            
+              case RequestNode::RequestMethods.index(method) <=> RequestNode::RequestMethods.index(current_node.request_method)
+              when 0 #use this node
+                if request_options[method].is_a?(Regexp)
+                  current_node = RequestNode.new
+                  current_node.linear << [request_options[method], current_node]
+                elsif request_options[method].is_a?(Array)
+                  current_nodes[current_node_index] = request_options[method].map{|val| current_node.lookup[val] ||= RequestNode.new}
+                else
+                  current_nodes[current_node_index] = (current_node.lookup[request_options[method]] ||= RequestNode.new)
                 end
-              else
-                current_nodes[current_node_index] = RequestNode.new
+              when 1 #this node is farther ahead
+                current_nodes[current_node_index] = (current_node.catchall ||= RequestNode.new)
+                redo
+              when -1 #this method is more important than the current node
+                new_node = RequestNode.new
+                new_node.request_method = method
+                new_node.catchall = current_node
+                current_nodes[current_node_index] = new_node
                 redo
               end
-            elsif !current_node
-              @request_node = RequestNode.new
-              current_nodes[current_node_index] = @request_node
-              redo
             else
-              current_node.catchall ||= RequestNode.new
+              current_nodes[current_node_index] = RequestNode.new
+              redo
             end
+          elsif !current_node
+            @request_node = RequestNode.new
+            current_nodes[current_node_index] = @request_node
+            redo
+          else
+            current_node.catchall ||= RequestNode.new
           end
-          current_nodes.flatten!
         end
-        if @value
-          target_node = @request_node
-          while target_node.request_method
-            target_node = (target_node.catchall ||= RequestNode.new)
+        current_nodes.flatten!
+      end
+      transplant_value
+      current_nodes
+    end
+
+    def find_on_request_methods(request)
+      current_node = self
+      if current_node && current_node.request_node
+        current_node = current_node.request_node
+        while current_node
+          previous_node = current_node
+          break if current_node.nil? || current_node.is_a?(RoutingError) || current_node.value
+          request_value = request.send(current_node.request_method)
+          unless current_node.linear.empty?
+            next_node = current_node.linear.find do |(regexp, node)|
+              regexp === request_value
+            end
+            if next_node
+              current_node = next_node.last
+              next
+            end
+          end
+          current_node = current_node.lookup[request_value] || current_node.catchall
+          if current_node.nil?
+            current_node = previous_node.request_method == :request_method ? RoutingError.new(405, {"Allow" => previous_node.lookup.keys.join(", ")}) : nil
+          else
+            current_node
           end
-          target_node.value = @value
-          @value = nil
-        end
-        current_nodes
-      elsif @request_node
-        current_node = @request_node
-        while current_node.request_method
-          current_node = (current_node.catchall ||= RequestNode.new)
         end
-        [current_node]
-      else
-        [self]
       end
+      current_node
     end
+
   end
   
   class RequestNode < Node

data/lib/http_router/path.rb

@@ -1,10 +1,11 @@
+require 'cgi'
 class HttpRouter
   class Path
     attr_reader :parts, :extension
     attr_accessor :route
     def initialize(path, parts, extension)
       @path, @parts, @extension = path, parts, extension
-      @eval_path = path.gsub(/[:\*]([a-zA-Z0-9_]+)/) {"\#{args.shift || (options && options[:#{$1}]) || raise(MissingParameterException.new(\"missing parameter #{$1}\"))}" }
+      @eval_path = path.gsub(/[:\*]([a-zA-Z0-9_]+)/) {"\#{args.shift || (options && options.delete(:#{$1})) || raise(MissingParameterException.new(\"missing parameter #{$1}\"))}" }
       instance_eval "
       def raw_url(args,options)
         \"#{@eval_path}\"
@@ -16,9 +17,25 @@ class HttpRouter
       path = raw_url(args, options)
       raise TooManyParametersException.new unless args.empty?
       Rack::Utils.uri_escape!(path)
+      generate_querystring(path, options)
       path
     end
 
+    def generate_querystring(uri, params)
+      if params && !params.empty?
+        uri_size = uri.size
+        params.each do |k,v|
+          case v
+          when Array
+            v.each { |v_part| uri << '&' << CGI.escape(k.to_s) << '%5B%5D=' << CGI.escape(v_part.to_s) }
+          else
+            uri << '&' << CGI.escape(k.to_s) << '=' << CGI.escape(v.to_s)
+          end
+        end
+        uri[uri_size] = ??
+      end
+    end
+
     def variables
       unless @variables
         @variables = @parts.select{|p| p.is_a?(Variable)}
@@ -28,7 +45,7 @@ class HttpRouter
     end
 
     def variable_names
-      variables.map{|v| v.name}
+      @variable_names ||= variables.map{|v| v.name}
     end
 
     def matches_extension?(extension)

data/lib/http_router/response.rb

@@ -13,6 +13,11 @@ class HttpRouter
       path.route
     end
     
+    def dest
+      route.dest
+    end
+    alias_method :destination, :dest
+    
     def partial_match?
       remaining_path
     end

data/lib/http_router/root.rb

@@ -5,17 +5,38 @@ class HttpRouter
       reset!
     end
 
+    def add_path(path)
+      node = path.parts.inject(self) { |node, part| node.add(part) }
+      if path.extension
+        node = node.add_extension(path.extension)
+      end
+      node
+    end
+
     def find(request)
       path = request.path_info.dup
       path.slice!(-1) if @base.ignore_trailing_slash? && path[-1] == ?/
-      path.gsub!(/\.([^\/\.]+)$/, '')
-      extension = $1
+      extension = extract_extension(path)
       parts = @base.split(path)
       parts << '' if path[path.size - 1] == ?/
 
-      current_node = self
       params = []
-      while current_node
+      if current_node = process_parts(parts, extension, params)
+        current_node = current_node.find_on_request_methods(request)
+      end
+      
+      process_response(current_node, parts, extension, params, request)
+    end
+    
+    private
+    
+    def process_parts(parts, extension, params)
+      current_node = self
+      loop do
+        if parts.empty? && current_node.extension_node && extension
+          parts << extension
+          current_node = current_node.extension_node
+        end
         break if current_node.nil? || (current_node.value && current_node.value.route.partially_match?) || parts.empty?
         unless current_node.linear.empty?
           whole_path = parts.join('/')
@@ -49,41 +70,21 @@ class HttpRouter
           break
         else
           current_node = nil
+          break
         end
       end
-      
-      if current_node && current_node.request_node
-        current_node = current_node.request_node
-        while current_node
-          previous_node = current_node
-          break if current_node.nil? || current_node.is_a?(RoutingError) || current_node.value
-          request_value = request.send(current_node.request_method)
-          unless current_node.linear.empty?
-            next_node = current_node.linear.find do |(regexp, node)|
-              regexp === request_value
-            end
-            if next_node
-              current_node = next_node.last
-              next
-            end
-          end
-          current_node = current_node.lookup[request_value] || current_node.catchall
-          if current_node.nil?
-            current_node = previous_node.request_method == :request_method ? RoutingError.new(405, {"Allow" => previous_node.lookup.keys.join(", ")}) : nil
-          else
-            current_node
-          end
-        end
-      end
-      if current_node.is_a?(RoutingError)
-        current_node
-      elsif current_node && current_node.value
+      current_node
+    end
+
+    def process_response(node, parts, extension, params, request)
+      if node.is_a?(RoutingError)
+        node
+      elsif node && node.value
         if parts.empty?
-          post_match(current_node.value, params, extension, request.path_info)
-        elsif current_node.value.route.partially_match?
+          post_match(node.value, params, extension, request.path_info)
+        elsif node.value.route.partially_match?
           rest = '/' << parts.join('/') << (extension ? ".#{extension}" : '')
-          
-          post_match(current_node.value, params, nil, request.path_info[0, request.path_info.size - rest.size], rest)
+          post_match(node.value, params, nil, request.path_info[0, request.path_info.size - rest.size], rest)
         else
           nil
         end
@@ -92,6 +93,14 @@ class HttpRouter
       end
     end
 
+    def extract_extension(path)
+      if path.gsub!(/\.([^\/\.]+)$/, '')
+        extension = $1
+      else
+        nil
+      end
+    end
+
     def post_match(path, params, extension, matched_path, remaining_path = nil)
       if path.route.partially_match? || path.matches_extension?(extension)
         Response.new(path, params, extension, matched_path, remaining_path)

data/lib/http_router/route.rb

@@ -3,14 +3,72 @@ class HttpRouter
     attr_reader :dest, :paths
     attr_accessor :trailing_slash_ignore, :partially_match, :default_values
 
-    def initialize(base, default_values)
-      @base, @default_values = base, default_values
-      @paths = []
+    def initialize(base, path)
+      @base = base
+      @path = path
+      @original_path = path.dup
+      @partially_match = extract_partial_match(path)
+      @trailing_slash_ignore = extract_trailing_slash(path)
+      @variable_store = {}
+      @matches_with = {}
+      @conditions =  {}
+    end
+
+    def method_missing(method, *args, &block)
+      if RequestNode::RequestMethods.include?(method)
+        condition(method => args)
+      else
+        super
+      end
     end
 
     def name(name)
       @name = name
-      @base.routes[name] = self
+      @base.named_routes[name] = self
+    end
+
+    def get
+      request_method('GET', 'HEAD')
+    end
+    
+    def post
+      request_method('POST')
+    end
+    
+    def head
+      request_method('head')
+    end
+    
+    def put
+      request_method('PUT')
+    end
+    
+    def delete
+      request_method('DELETE')
+    end
+    
+    def only_get
+      request_method('DELETE')
+    end
+      
+    def condition(conditions)
+      guard_compiled
+      conditions.each do |k,v|
+        @conditions.key?(k) ?
+          @conditions[k] << v :
+          @conditions[k] = Array(v)
+      end
+      self
+    end
+    alias_method :conditions, :condition
+
+    def matching(*match)
+      guard_compiled
+      @matches_with.merge!(match.pop) if match.last.is_a?(Hash)
+      match.each_slice(2) do |(k,v)|
+        @matches_with[k] = v
+      end
+      self
     end
 
     def named
@@ -18,19 +76,38 @@ class HttpRouter
     end
 
     def to(dest = nil, &block)
+      compile
       @dest = dest || block
       self
     end
 
-    def match_partially!(match = true)
+    def partial(match = true)
       @partially_match = match
       self
     end
   
-    def redirect(path, status = 302)
-      unless (300..399).include?(status)
-        raise ArgumentError, "Status has to be an integer between 300 and 399"
+    def compiled?
+      !@paths.nil?
+    end
+  
+    def compile
+      unless @paths
+        @paths = compile_paths
+        @paths.each do |path|
+          path.route = self
+          current_node = @base.root.add_path(path)
+          working_set = current_node.add_request_methods(@conditions)
+          working_set.each do |current_node|
+            current_node.value = path
+          end
+        end
       end
+      self
+    end
+  
+    def redirect(path, status = 302)
+      guard_compiled
+      raise(ArgumentError, "Status has to be an integer between 300 and 399") unless (300..399).include?(status)
       to { |env|
         params = env['router.params']
         response = ::Rack::Response.new
@@ -40,10 +117,11 @@ class HttpRouter
       self
     end
     
-    def serves_static_from(root)
+    def static(root)
+      guard_compiled
+      raise AlreadyCompiledException.new if compiled?
       if File.directory?(root)
-        match_partially!
-        to ::Rack::File.new(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)}
       end
@@ -60,11 +138,14 @@ class HttpRouter
 
     def url(*args)
       options = args.last.is_a?(Hash) ? args.pop : nil
+      options = default_values.merge(options) if default_values && options
       path = matching_path(args.empty? ? options : args)
       raise UngeneratableRouteException.new unless path
       path.url(args, options)
     end
 
+    private
+
     def matching_path(params)
       if @paths.size == 1
         @paths.first
@@ -77,26 +158,113 @@ class HttpRouter
           end
           nil
         else
-          maximum_matched_route = nil
-          maximum_matched_params = -1
-          @paths.each do |path|
-            param_count = 0
-            path.variables.each do |variable|
-              if params && params.key?(variable.name)
-                param_count += 1
-              else
-                param_count = -1
-                break
-              end
+          @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
+            end
+          end
+          nil
+        end
+      end
+    end
+    
+    def extract_partial_match(path)
+      path[-1] == ?* && path.slice!(-1)
+    end
+
+    def extract_trailing_slash(path)
+      path[-2, 2] == '/?' && path.slice!(-2, 2)
+    end
+
+    def extract_extension(path)
+      if match = path.match(/^(.*)(\.:([a-zA-Z_]+))$/)
+        path.replace(match[1])
+        Variable.new(@base, match[3].to_sym)
+      elsif match = path.match(/^(.*)(\.([a-zA-Z_]+))$/)
+        path.replace(match[1])
+        match[3]
+      end
+    end
+
+
+    def compile_optionals(path)
+      start_index = 0
+      end_index = 1
+
+      paths = [""]
+      chars = path.split('')
+
+      chars.each do |c|
+        case c
+          when '('
+            # over current working set, double paths
+            (start_index...end_index).each do |path_index|
+              paths << paths[path_index].dup
+            end
+            start_index = end_index
+            end_index = paths.size
+          when ')'
+            start_index -= end_index - start_index
+          else
+            (start_index...end_index).each do |path_index|
+              paths[path_index] << c
             end
-            if (param_count != -1 && param_count > maximum_matched_params)
-              maximum_matched_params = param_count;
-              maximum_matched_route = path;
+        end
+      end
+      paths
+    end
+
+    def compile_paths
+      paths = compile_optionals(@path)
+      paths.map do |path|
+        original_path = path.dup
+        extension = extract_extension(path)
+        new_path = @base.split(path).map do |part|
+          case part[0]
+          when ?:
+            v_name = part[1, part.size].to_sym
+            @variable_store[v_name] ||= Variable.new(@base, v_name, @matches_with[v_name])
+          when ?*
+            v_name = part[1, part.size].to_sym
+            @variable_store[v_name] ||= Glob.new(@base, v_name, @matches_with[v_name])
+          else
+            generate_interstitial_parts(part)
+          end
+        end
+        new_path.flatten!
+        Path.new(original_path, new_path, extension)
+      end
+    end
+
+    def generate_interstitial_parts(part)
+      part_segments = part.split(/(:[a-zA-Z_]+)/)
+      if part_segments.size > 1
+        index = 0
+        part_segments.map do |seg|
+          new_seg = if seg[0] == ?:
+            next_index = index + 1
+            scan_regex = if next_index == part_segments.size
+              /^[^\/]+/
+            else
+              /^.*?(?=#{Regexp.quote(part_segments[next_index])})/
             end
+            v_name = seg[1, seg.size].to_sym
+            @variable_store[v_name] ||= Variable.new(@base, v_name, scan_regex)
+          else
+            /^#{Regexp.quote(seg)}/
           end
-          maximum_matched_route
+          index += 1
+          new_seg
         end
+      else
+        part
       end
     end
+
+    def guard_compiled
+      raise AlreadyCompiledException.new if compiled?
+    end
   end
 end

data/lib/http_router/sinatra.rb

@@ -60,9 +60,6 @@ class HttpRouter
 
           def route(verb, path, options={}, &block)
             name = options.delete(:name)
-            options[:conditions] ||= {}
-            options[:conditions][:request_method] = verb
-            options[:conditions][:host] = options.delete(:host) if options.key?(:host)
 
             define_method "#{verb} #{path}", &block
             unbound_method = instance_method("#{verb} #{path}")
@@ -75,7 +72,11 @@ class HttpRouter
 
             invoke_hook(:route_added, verb, path, block)
 
-            route = router.add(path, options).to(block)
+            route = router.add(path)
+            route.request_method(verb)
+            route.host(options.delete(:host)) if options.key?(:host)
+            
+            route.to(block)
             route.name(name) if name
             route
           end

data/lib/http_router.rb

@@ -14,15 +14,18 @@ class HttpRouter
   UngeneratableRouteException = Class.new(RuntimeError)
   MissingParameterException   = Class.new(RuntimeError)
   TooManyParametersException  = Class.new(RuntimeError)
+  AlreadyCompiledException    = Class.new(RuntimeError)
   RoutingError                = Struct.new(:status, :headers)
 
-  attr_reader :routes
+  attr_reader :named_routes, :routes, :root
 
   def initialize(options = nil)
-    reset!
     @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
+    @routes = []
+    @named_routes = {}
+    reset!
   end
 
   def ignore_trailing_slash?
@@ -35,7 +38,8 @@ class HttpRouter
 
   def reset!
     @root = Root.new(self)
-    @routes = {}
+    @routes.clear
+    @named_routes.clear
   end
 
   def default(app)
@@ -47,150 +51,44 @@ class HttpRouter
     with_delimiter ? path.split('(/)') : path.split('/')
   end
 
-  def add(path, options = nil)
-    path = path.dup
-    partially_match       = extract_partial_match(path)
-    trailing_slash_ignore = extract_trailing_slash(path)
-    paths                 = compile(path, options)
-    
-    route = Route.new(self, options && options[:default_values])
-    route.trailing_slash_ignore = trailing_slash_ignore
-    route.partially_match = partially_match
-    paths.each_with_index do |path, i|
-      current_node = @root
-      path.parts.each { |part| current_node = current_node.add(part) }
-      working_set = current_node.add_request_methods(options)
-      working_set.each do |current_node|
-        current_node.value = path
-        path.route = route
-        route.paths << current_node.value
-      end
-    end
+  def add(path)
+    route = Route.new(self, path.dup)
+    @routes << route
     route
   end
 
-  def get(path, options = {})
-    options[:conditions] ||= {}
-    options[:conditions][:request_method] = ['HEAD', 'GET'] #TODO, this should be able to take an array
-    add(path, options)
-  end
-
-  def post(path, options = {})
-    options[:conditions] ||= {}
-    options[:conditions][:request_method] = 'POST'
-    add(path, options)
-  end
-
-  def put(path, options = {})
-    options[:conditions] ||= {}
-    options[:conditions][:request_method] = 'PUT'
-    add(path, options)
+  def get(path)
+    add(path).get
   end
 
-  def delete(path, options = {})
-    options[:conditions] ||= {}
-    options[:conditions][:request_method] = 'DELETE'
-    add(path, options)
+  def post(path)
+    add(path).post
   end
 
-  def only_get(path, options = {})
-    options[:conditions] ||= {}
-    options[:conditions][:request_method] = "GET"
-    add(path, options)
+  def put(path)
+    add(path).put
   end
 
-  def extract_partial_match(path)
-    if path[-1] == ?*
-      path.slice!(-1)
-      true
-    else
-      false
-    end
+  def delete(path)
+    add(path).delete
   end
 
-  def extract_trailing_slash(path)
-    if path[-2, 2] == '/?'
-      path.slice!(-2, 2)
-      true
-    else
-      false
-    end
+  def only_get(path)
+    add(path).only_get
   end
 
-  def extract_extension(path)
-    if match = path.match(/^(.*)(\.:([a-zA-Z_]+))$/)
-      path.replace(match[1])
-      Variable.new(self, match[3].to_sym)
-    elsif match = path.match(/^(.*)(\.([a-zA-Z_]+))$/)
-      path.replace(match[1])
-      match[3]
-    end
+  def recognize(env)
+    response = @root.find(env.is_a?(Hash) ? Rack::Request.new(env) : env)
   end
 
-  def compile(path, options)
-    start_index = 0
-    end_index = 1
-
-    paths = [""]
-    chars = path.split('')
-
-    chars.each do |c|
-      case c
-        when '('
-          # over current working set, double paths
-          (start_index...end_index).each do |path_index|
-            paths << paths[path_index].dup
-          end
-          start_index = end_index
-          end_index = paths.size
-        when ')'
-          start_index -= end_index - start_index
-        else
-          (start_index...end_index).each do |path_index|
-            paths[path_index] << c
-          end
-      end
-    end
-    
-    variables = {}
-    paths.map do |path|
-      original_path = path.dup
-      extension = extract_extension(path)
-      new_path = split(path).map do |part|
-        case part[0]
-        when ?:
-          v_name = part[1, part.size].to_sym
-          variables[v_name] ||= Variable.new(self, v_name, options && options[:matches_with] && options && options[:matches_with][v_name])
-        when ?*
-          v_name = part[1, part.size].to_sym
-          variables[v_name] ||= Glob.new(self, v_name, options && options[:matches_with] && options && options[:matches_with][v_name])
-        else
-          part_segments = part.split(/(:[a-zA-Z_]+)/)
-          if part_segments.size > 1
-            index = 0
-            part_segments.map do |seg|
-              new_seg = if seg[0] == ?:
-                next_index = index + 1
-                scan_regex = if next_index == part_segments.size
-                  /^[^\/]+/
-                else
-                  /^.*?(?=#{Regexp.quote(part_segments[next_index])})/
-                end
-                v_name = seg[1, seg.size].to_sym
-                variables[v_name] ||= Variable.new(self, v_name, scan_regex)
-              else
-                /^#{Regexp.quote(seg)}/
-              end
-              index += 1
-              new_seg
-            end
-          else
-            part
-          end
-        end
-      end
-      new_path.flatten!
-      Path.new(original_path, new_path, extension)
+  def url(route, *args)
+    case route
+      when Symbol
+        url(@named_routes[route], *args)
+      when nil
+        raise UngeneratableRouteException.new
+      else
+        route.url(*args)
     end
   end
 
@@ -208,10 +106,6 @@ class HttpRouter
       elsif response && response.route.dest && response.route.dest.respond_to?(:call)
         process_params(env, response)
         consume_path!(request, response) if response.partial_match?
-        #if response.rest
-        #  request.env["SCRIPT_NAME"] += request.env["PATH_INFO"][0, -response.rest.size]
-        #  request.env["PATH_INFO"] = response.rest || ''
-        #end
         response.route.dest.call(env)
       else
         @default_app.call(env)
@@ -219,6 +113,8 @@ class HttpRouter
     end
   end
 
+  private
+
   def consume_path!(request, response)
     request.env["SCRIPT_NAME"] = (request.env["SCRIPT_NAME"] + response.matched_path)
     request.env["PATH_INFO"] = response.remaining_path || ""
@@ -233,18 +129,4 @@ class HttpRouter
     end
   end
 
-  def recognize(env)
-    response = @root.find(env.is_a?(Hash) ? Rack::Request.new(env) : env)
-  end
-
-  def url(route, *args)
-    case route
-      when Symbol
-        url(@routes[route], *args)
-      when nil
-        raise UngeneratableRouteException.new
-      else
-        route.url(*args)
-    end
-  end
 end

data/spec/generate_spec.rb

@@ -6,7 +6,7 @@ describe "HttpRouter#generate" do
   context("static paths") do
     ['/', '/test', '/test/time', '/one/more/what', '/test.html'].each do |path|
       it "should generate #{path.inspect}" do
-        route = @router.add(path)
+        route = @router.add(path).compile
         @router.url(route).should == path
       end
     end
@@ -14,34 +14,44 @@ describe "HttpRouter#generate" do
 
   context("dynamic paths") do
     it "should generate from a hash" do
-      @router.add("/:var").name(:test)
+      @router.add("/:var").name(:test).compile
       @router.url(:test, :var => 'test').should == '/test'
     end
 
+    it "should generate from a hash with extra parts going to the query string" do
+      @router.add("/:var").name(:test).compile
+      @router.url(:test, :var => 'test', :query => 'string').should == '/test?query=string'
+    end
+
     it "should generate from an array" do
-      @router.add("/:var").name(:test)
+      @router.add("/:var").name(:test).compile
       @router.url(:test, 'test').should == '/test'
     end
 
+    it "should generate from an array with extra parts going to the query string" do
+      @router.add("/:var").name(:test).compile
+      @router.url(:test, 'test', :query => 'string').should == '/test?query=string'
+    end
+
     it "should generate with a format" do
-      @router.add("/test.:format").name(:test)
+      @router.add("/test.:format").name(:test).compile
       @router.url(:test, 'html').should == '/test.html'
     end
 
     it "should generate with a format as a hash" do
-      @router.add("/test.:format").name(:test)
+      @router.add("/test.:format").name(:test).compile
       @router.url(:test, :format => 'html').should == '/test.html'
     end
 
     it "should generate with an optional format" do
-      @router.add("/test(.:format)").name(:test)
+      @router.add("/test(.:format)").name(:test).compile
       @router.url(:test, 'html').should == '/test.html'
       @router.url(:test).should == '/test'
     end
 
     context "with optional parts" do
       it "should generate both" do
-        @router.add("/:var1(/:var2)").name(:test)
+        @router.add("/:var1(/:var2)").name(:test).compile
         @router.url(:test, 'var').should == '/var'
         @router.url(:test, 'var', 'fooz').should == '/var/fooz'
         @router.url(:test, :var1 => 'var').should == '/var'

data/spec/rack/dispatch_spec.rb

@@ -25,7 +25,7 @@ describe "Usher (for rack) route dispatching" do
   describe "HTTP GET" do
     before(:each) do
       route_set.reset!
-      route_set.add('/sample', :conditions => {:request_method => 'GET'}).to(@app)
+      route_set.add('/sample').request_method('GET').to(@app)
     end
 
     it "should dispatch a request" do
@@ -42,7 +42,7 @@ describe "Usher (for rack) route dispatching" do
   describe "HTTP POST" do
     before(:each) do
       route_set.reset!
-      route_set.add('/sample', :conditions => {:request_method => 'POST'}).to(@app)
+      route_set.add('/sample').post.to(@app)
       route_set.add('/sample').to(MockApp.new("You shouldn't get here if you are using POST"))
     end
 
@@ -64,8 +64,8 @@ describe "Usher (for rack) route dispatching" do
 
   it "should returns HTTP 405 if the method mis-matches" do
     route_set.reset!
-    route_set.add('/sample', :conditions => {:request_method => 'POST'}).to(@app)
-    route_set.add('/sample', :conditions => {:request_method => 'PUT'}).to(@app)
+    route_set.post('/sample').to(@app)
+    route_set.put('/sample').to(@app)
     response = route_set.call_with_mock_request('/sample', 'GET')
     response.status.should eql(405)
     response['Allow'].should == 'POST, PUT'

data/spec/rack/generate_spec.rb

@@ -5,9 +5,9 @@ describe "Usher (for rack) route generation" do
   before(:each) do
     route_set.reset!
     @app = MockApp.new("Hello World!")
-    route_set.add("/fixed").name(:fixed)
-    route_set.add("/named/simple/:named_simple_var").name(:simple)
-    route_set.add("/named/optional(/:named_optional_var)").name(:optional)
+    route_set.add("/fixed").name(:fixed).compile
+    route_set.add("/named/simple/:named_simple_var").name(:simple).compile
+    route_set.add("/named/optional(/:named_optional_var)").name(:optional).compile
   end
   
   describe "named routes" do

data/spec/rack/route_spec.rb

@@ -29,14 +29,14 @@ describe "Rack interface extensions for Usher::Route" do
 
   describe "static file serving" do
     it "should serve from a static directory" do
-      @route_set.get("/static").serves_static_from(File.dirname(__FILE__))
+      @route_set.get("/static").static(File.dirname(__FILE__))
       @env = Rack::MockRequest.env_for("/static/#{File.basename(__FILE__)}")
       status, headers, body = @route_set.call(@env)
       body.path.should == File.join(File.dirname(__FILE__), File.basename(__FILE__))
     end
 
     it "should serve a specific file" do
-      @route_set.get("/static-file").serves_static_from(__FILE__)
+      @route_set.get("/static-file").static(__FILE__)
       @env = Rack::MockRequest.env_for("/static-file")
       status, headers, body = @route_set.call(@env)
       body.path.should == __FILE__

data/spec/recognize_spec.rb

@@ -6,14 +6,14 @@ describe "HttpRouter#recognize" do
   context("static paths") do
     ['/', '/test', '/test/time', '/one/more/what', '/test.html'].each do |path|
       it "should recognize #{path.inspect}" do
-        route = @router.add(path)
+        route = @router.add(path).to(path)
         @router.recognize(Rack::MockRequest.env_for(path)).route.should == route
       end
     end
 
     context("with optional parts") do
       it "work either way" do
-        route = @router.add("/test(/optional)")
+        route = @router.add("/test(/optional)").to(:test)
         @router.recognize(Rack::MockRequest.env_for('/test')).route.should == route
         @router.recognize(Rack::MockRequest.env_for('/test/optional')).route.should == route
       end
@@ -21,7 +21,7 @@ describe "HttpRouter#recognize" do
 
     context("partial matching") do
       it "should match partially or completely" do
-        route = @router.add("/test*")
+        route = @router.add("/test*").to(:test)
         @router.recognize(Rack::MockRequest.env_for('/test')).route.should == route
         response = @router.recognize(Rack::MockRequest.env_for('/test/optional'))
         response.route.should == route
@@ -31,19 +31,19 @@ describe "HttpRouter#recognize" do
 
     context("trailing slashes") do
       it "should ignore a trailing slash" do
-        route = @router.add("/test")
+        route = @router.add("/test").to(:test)
         @router.recognize(Rack::MockRequest.env_for('/test/')).route.should == route
       end
 
       it "should not recognize a trailing slash when used with the /? syntax and ignore_trailing_slash disabled" do
         @router = HttpRouter.new(:ignore_trailing_slash => false)
-        route = @router.add("/test/?")
+        route = @router.add("/test/?").to(:test)
         @router.recognize(Rack::MockRequest.env_for('/test/')).route.should == route
       end
 
       it "should recognize a trailing slash when used with the /? syntax and ignore_trailing_slash enabled" do
         @router = HttpRouter.new(:ignore_trailing_slash => false)
-        route = @router.add("/test")
+        route = @router.add("/test").to(:test)
         @router.recognize(Rack::MockRequest.env_for('/test/')).should be_nil
       end
     end
@@ -52,30 +52,30 @@ describe "HttpRouter#recognize" do
 
   context "request methods" do
     it "should pick a specific request_method" do
-      route = @router.add("/test", :conditions => {:request_method => 'POST'})
+      route = @router.post("/test").to(:test)
       @router.recognize(Rack::MockRequest.env_for('/test', :method => 'POST')).route.should == route
       @router.recognize(Rack::MockRequest.env_for('/test', :method => 'GET')).status.should == 405
       @router.recognize(Rack::MockRequest.env_for('/test', :method => 'GET')).headers['Allow'].should == "POST"
     end
 
     it "should pick a specific request_method with other paths all through it" do
-      @router.add("/test", :conditions => {:request_method => 'POST'}).name(:test_post)
-      @router.add("/test/post", :conditions => {:request_method => 'POST'}).name(:test_post_post)
-      @router.add("/test", :conditions => {:request_method => 'GET'}).name(:test_get)
-      @router.add("/test/post", :conditions => {:request_method => 'GET'}).name(:test_post_get)
-      @router.add("/test/post").name(:test_post_catchall)
-      @router.add("/test").name(:test_catchall)
-      @router.recognize(Rack::MockRequest.env_for('/test', :method => 'POST')).route.named.should == :test_post
-      @router.recognize(Rack::MockRequest.env_for('/test', :method => 'GET')).route.named.should == :test_get
-      @router.recognize(Rack::MockRequest.env_for('/test', :method => 'PUT')).route.named.should == :test_catchall
-      @router.recognize(Rack::MockRequest.env_for('/test/post', :method => 'POST')).route.named.should == :test_post_post
-      @router.recognize(Rack::MockRequest.env_for('/test/post', :method => 'GET')).route.named.should == :test_post_get
-      @router.recognize(Rack::MockRequest.env_for('/test/post', :method => 'PUT')).route.named.should == :test_post_catchall
+      @router.post("/test").to(:test_post)
+      @router.post("/test/post").to(:test_post_post)
+      @router.get("/test").to(:test_get)
+      @router.get("/test/post").to(:test_post_get)
+      @router.add("/test/post").to(:test_post_catchall)
+      @router.add("/test").to(:test_catchall)
+      @router.recognize(Rack::MockRequest.env_for('/test', :method => 'POST')).dest.should == :test_post
+      @router.recognize(Rack::MockRequest.env_for('/test', :method => 'GET')).dest.should == :test_get
+      @router.recognize(Rack::MockRequest.env_for('/test', :method => 'PUT')).dest.should == :test_catchall
+      @router.recognize(Rack::MockRequest.env_for('/test/post', :method => 'POST')).dest.should == :test_post_post
+      @router.recognize(Rack::MockRequest.env_for('/test/post', :method => 'GET')).dest.should == :test_post_get
+      @router.recognize(Rack::MockRequest.env_for('/test/post', :method => 'PUT')).dest.should == :test_post_catchall
     end
 
     it "should move an endpoint to the non-specific request method when a more specific route gets added" do
-      @router.add("/test").name(:test_catchall)
-      @router.add("/test", :conditions => {:request_method => 'POST'}).name(:test_post)
+      @router.add("/test").name(:test_catchall).to(:test1)
+      @router.post("/test").request_method('POST').name(:test_post).to(:test2)
       @router.recognize(Rack::MockRequest.env_for('/test', :method => 'POST')).route.named.should == :test_post
       @router.recognize(Rack::MockRequest.env_for('/test', :method => 'PUT')).route.named.should == :test_catchall
     end
@@ -84,7 +84,7 @@ describe "HttpRouter#recognize" do
 
   context("dynamic paths") do
     it "should recognize '/:variable'" do
-      route = @router.add('/:variable')
+      route = @router.add('/:variable').to(:test)
       response = @router.recognize(Rack::MockRequest.env_for('/value'))
       response.route.should == route
       response.params.should == ['value']
@@ -92,15 +92,16 @@ describe "HttpRouter#recognize" do
     end
 
     it "should recognize '/test.:format'" do
-      route = @router.add('/test.:format')
+      route = @router.add('/test.:format').to(:test)
       response = @router.recognize(Rack::MockRequest.env_for('/test.html'))
       response.route.should == route
       response.extension.should == 'html'
       response.params_as_hash[:format].should == 'html'
+      @router.recognize(Rack::MockRequest.env_for('/test')).should be_nil
     end
 
     it "should recognize '/test(.:format)'" do
-      route = @router.add('/test(.:format)')
+      route = @router.add('/test(.:format)').to(:test)
       response = @router.recognize(Rack::MockRequest.env_for('/test.html'))
       response.route.should == route
       response.extension.should == 'html'
@@ -112,7 +113,7 @@ describe "HttpRouter#recognize" do
     end
 
     it "should recognize '/:test.:format'" do
-      route = @router.add('/:test.:format')
+      route = @router.add('/:test.:format').to(:test)
       response = @router.recognize(Rack::MockRequest.env_for('/hey.html'))
       response.route.should == route
       response.extension.should == 'html'
@@ -121,7 +122,7 @@ describe "HttpRouter#recognize" do
     end
 
     it "should recognize '/:test(.:format)'" do
-      route = @router.add('/:test(.:format)')
+      route = @router.add('/:test(.:format)').to(:test)
       response = @router.recognize(Rack::MockRequest.env_for('/hey.html'))
       response.route.should == route
       response.extension.should == 'html'
@@ -136,13 +137,13 @@ describe "HttpRouter#recognize" do
     
     context "globs" do
       it "should recognize a glob" do
-        route = @router.add('/test/*variable')
+        route = @router.add('/test/*variable').to(:test)
         response = @router.recognize(Rack::MockRequest.env_for('/test/one/two/three'))
         response.route.should == route
         response.params.should == [['one', 'two', 'three']]
       end
       it "should recognize a glob with a regexp" do
-        route = @router.add('/test/*variable/anymore', :matches_with => {:variable => /^\d+$/})
+        route = @router.add('/test/*variable/anymore').matching(:variable => /^\d+$/).to(:test)
         response = @router.recognize(Rack::MockRequest.env_for('/test/123/345/567/anymore'))
         response.route.should == route
         response.params.should == [['123', '345', '567']]
@@ -155,7 +156,7 @@ describe "HttpRouter#recognize" do
   
   context("interstitial variables") do
     it "should recognize interstitial variables" do
-      route = @router.add('/one-:variable-time')
+      route = @router.add('/one-:variable-time').to(:test)
       response = @router.recognize(Rack::MockRequest.env_for('/one-value-time'))
       response.route.should == route
       response.params_as_hash[:variable].should == 'value'
@@ -164,7 +165,7 @@ describe "HttpRouter#recognize" do
 
   context("dynamic greedy paths") do
     it "should recognize greedy variables" do
-      route = @router.add('/:variable', :matches_with => { :variable => /\d+/})
+      route = @router.add('/:variable').matching(:variable, /\d+/).to(:test)
       response = @router.recognize(Rack::MockRequest.env_for('/123'))
       response.route.should == route
       response.params.should == ['123']

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Joshua Hull
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-25 00:00:00 -04:00
+date: 2010-05-27 00:00:00 -04:00
 default_executable: 
 dependencies: []