http_router 0.1.0 → 0.1.1

data/lib/http_router/route.rb

@@ -4,14 +4,25 @@ class HttpRouter
     attr_accessor :trailing_slash_ignore, :partially_match, :default_values
 
     def initialize(base, path)
-      @base = base
+      @router = base
       @path = path
       @original_path = path.dup
       @partially_match = extract_partial_match(path)
       @trailing_slash_ignore = extract_trailing_slash(path)
       @variable_store = {}
       @matches_with = {}
+      @additional_matchers = {}
       @conditions =  {}
+      @default_values = {}
+    end
+
+    def significant_variable_names
+      unless @significant_variable_names
+        @significant_variable_names = @paths.map { |p| p.variable_names }
+        @significant_variable_names.flatten!
+        @significant_variable_names.uniq!
+      end
+      @significant_variable_names
     end
 
     def method_missing(method, *args, &block)
@@ -22,9 +33,27 @@ class HttpRouter
       end
     end
 
+    def with_options(options)
+      if options && options[:matching]
+        default(options[:matching])
+      end
+      if options && options[:conditions]
+        condition(options[:conditions])
+      end
+      if options && options[:default_values]
+        default(options[:default_values])
+      end
+      self
+    end
+
     def name(name)
       @name = name
-      @base.named_routes[name] = self
+      router.named_routes[name] = self
+    end
+
+    def default(v)
+      @default_values.merge!(v)
+      self
     end
 
     def get
@@ -36,7 +65,7 @@ class HttpRouter
     end
     
     def head
-      request_method('head')
+      request_method('HEAD')
     end
     
     def put
@@ -62,11 +91,19 @@ class HttpRouter
     end
     alias_method :conditions, :condition
 
-    def matching(*match)
+    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
+      match.each do |var_name, matchers|
+        matchers = Array(matchers)
+        matchers.each do |m|
+          if m.respond_to?(:call)
+            (@additional_matchers[var_name] ||= []) << m
+          else
+            @matches_with.key?(var_name) ?
+              raise :
+              @matches_with[var_name] = m
+          end    
+        end
       end
       self
     end
@@ -93,9 +130,14 @@ class HttpRouter
     def compile
       unless @paths
         @paths = compile_paths
+        @paths.each_with_index do |p1, i|
+          @paths[i+1, @paths.size].each do |p2|
+            raise AmbiguousRouteException.new if p1 === p2
+          end
+        end
         @paths.each do |path|
           path.route = self
-          current_node = @base.root.add_path(path)
+          current_node = router.root.add_path(path)
           working_set = current_node.add_request_methods(@conditions)
           working_set.each do |current_node|
             current_node.value = path
@@ -138,25 +180,31 @@ class HttpRouter
 
     def url(*args)
       options = args.last.is_a?(Hash) ? args.pop : nil
+      options ||= {} if default_values
       options = default_values.merge(options) if default_values && options
-      path = matching_path(args.empty? ? options : args)
+      path = if args.empty?
+        matching_path(options)
+      else
+        matching_path(args, options)
+      end
       raise UngeneratableRouteException.new unless path
       path.url(args, options)
     end
 
     private
+    
+    attr_reader :router
 
-    def matching_path(params)
+    def matching_path(params, other_hash = nil)
       if @paths.size == 1
         @paths.first
       else
         if params.is_a?(Array)
-          @paths.each do |path|
-            if path.variables.size == params.size
-              return path
-            end
-          end
-          nil
+          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
+          }
         else
           @paths.reverse_each do |path|
             if params && !params.empty?
@@ -181,7 +229,8 @@ class HttpRouter
     def extract_extension(path)
       if match = path.match(/^(.*)(\.:([a-zA-Z_]+))$/)
         path.replace(match[1])
-        Variable.new(@base, match[3].to_sym)
+        v_name = match[3].to_sym
+        router.variable(match[3].to_sym, @matches_with[v_name], @additional_matchers && @additional_matchers[v_name])
       elsif match = path.match(/^(.*)(\.([a-zA-Z_]+))$/)
         path.replace(match[1])
         match[3]
@@ -221,14 +270,14 @@ class HttpRouter
       paths.map do |path|
         original_path = path.dup
         extension = extract_extension(path)
-        new_path = @base.split(path).map do |part|
+        new_path = router.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])
+            @variable_store[v_name] ||= router.variable(v_name, @matches_with[v_name], @additional_matchers && @additional_matchers[v_name])
           when ?*
             v_name = part[1, part.size].to_sym
-            @variable_store[v_name] ||= Glob.new(@base, v_name, @matches_with[v_name])
+            @variable_store[v_name] ||= router.glob(v_name, @matches_with[v_name], @additional_matchers && @additional_matchers[v_name])
           else
             generate_interstitial_parts(part)
           end
@@ -245,13 +294,14 @@ class HttpRouter
         part_segments.map do |seg|
           new_seg = if seg[0] == ?:
             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
-              /^.*?(?=#{Regexp.quote(part_segments[next_index])})/
+              /^#{matcher || '.*?'}(?=#{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)
+            @variable_store[v_name] ||= router.variable(v_name, scan_regex, @additional_matchers && @additional_matchers[v_name])
           else
             /^#{Regexp.quote(seg)}/
           end

data/lib/http_router/variable.rb

@@ -2,25 +2,32 @@ class HttpRouter
   class Variable
     attr_reader :name, :matches_with
 
-    def initialize(base, name, matches_with = nil)
-      @base = base
+    def initialize(base, name, matches_with = nil, additional_matchers = nil)
+      @router = base
       @name = name
       @matches_with = matches_with
+      @additional_matchers = additional_matchers
     end
-    
-    def matches(parts, whole_path)
+
+    def matches(env, parts, whole_path)
       if @matches_with.nil?
-        parts.first
-      elsif @matches_with && match = @matches_with.match(whole_path)
+        additional_matchers(env, parts.first) ? parts.first : nil
+      elsif @matches_with and match = @matches_with.match(whole_path) and additional_matchers(env, parts.first)
         whole_path.slice!(0, match[0].size)
-        parts.replace(@base.split(whole_path))
+        parts.replace(router.split(whole_path))
         match[0]
       end
     end
-    
+
+    def additional_matchers(env, test)
+      @additional_matchers.nil? || @additional_matchers.all?{|m| m.call(env, test)}
+    end
+
     def ===(part)
       @matches_with.nil?
     end
-    
+
+    protected
+      attr_reader :router
   end
 end

data/lib/http_router.rb

@@ -1,6 +1,6 @@
 $LOAD_PATH << File.dirname(__FILE__)
 require 'rack'
-require 'rack/uri_escape'
+require 'ext/rack/uri_escape'
 
 class HttpRouter
   autoload :Node,     'http_router/node'
@@ -11,21 +11,24 @@ class HttpRouter
   autoload :Response, 'http_router/response'
   autoload :Path,     'http_router/path'
 
-  UngeneratableRouteException = Class.new(RuntimeError)
-  MissingParameterException   = Class.new(RuntimeError)
-  TooManyParametersException  = Class.new(RuntimeError)
-  AlreadyCompiledException    = Class.new(RuntimeError)
-  RoutingError                = Struct.new(:status, :headers)
+  UngeneratableRouteException      = Class.new(RuntimeError)
+  MissingParameterException        = Class.new(RuntimeError)
+  TooManyParametersException       = Class.new(RuntimeError)
+  AlreadyCompiledException         = Class.new(RuntimeError)
+  AmbiguousRouteException          = Class.new(RuntimeError)
+  UnsupportedRequestConditionError = Class.new(RuntimeError)
+  AmbiguousVariableException       = Class.new(RuntimeError)
 
   attr_reader :named_routes, :routes, :root
 
-  def initialize(options = nil)
+  def initialize(options = nil, &block)
     @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!
+    instance_eval(&block) if block
   end
 
   def ignore_trailing_slash?
@@ -46,41 +49,41 @@ class HttpRouter
     @default_app = app
   end
   
-  def split(path, with_delimiter = false)
-    path.slice!(0) if path[0] == ?/
-    with_delimiter ? path.split('(/)') : path.split('/')
+  def split(path)
+    (path[0] == ?/ ? path[1, path.size] : path).split('/')
   end
 
-  def add(path)
-    route = Route.new(self, path.dup)
+  def add(path, options = nil)
+    route = Route.new(self, path.dup).with_options(options)
     @routes << route
     route
   end
 
-  def get(path)
-    add(path).get
+  def get(path, options = nil)
+    add(path, options).get
   end
 
-  def post(path)
-    add(path).post
+  def post(path, options = nil)
+    add(path, options).post
   end
 
-  def put(path)
-    add(path).put
+  def put(path, options = nil)
+    add(path, options).put
   end
 
-  def delete(path)
-    add(path).delete
+  def delete(path, options = nil)
+    add(path, options).delete
   end
 
-  def only_get(path)
-    add(path).only_get
+  def only_get(path, options = nil)
+    add(path, options).only_get
   end
 
   def recognize(env)
     response = @root.find(env.is_a?(Hash) ? Rack::Request.new(env) : env)
   end
 
+  # Generate a URL for a specified route.
   def url(route, *args)
     case route
       when Symbol
@@ -92,6 +95,7 @@ class HttpRouter
     end
   end
 
+  # Allow the router to be called via Rake / Middleware.
   def call(env)
     request = Rack::Request.new(env)
     if redirect_trailing_slash? && (request.head? || request.get?) && request.path_info[-1] == ?/
@@ -99,19 +103,39 @@ class HttpRouter
       response.redirect(request.path_info[0, request.path_info.size - 1], 302)
       response.finish
     else
-      response = recognize(request)
       env['router'] = self
-      if response.is_a?(RoutingError)
-        [response.status, response.headers, []]
-      elsif response && response.route.dest && response.route.dest.respond_to?(:call)
-        process_params(env, response)
-        consume_path!(request, response) if response.partial_match?
-        response.route.dest.call(env)
-      else
-        @default_app.call(env)
+      if response = recognize(request)
+        if response.matched? && response.route.dest && response.route.dest.respond_to?(:call)
+          process_params(env, response)
+          consume_path!(request, response) if response.partial_match?
+          return response.route.dest.call(env)
+        elsif !response.matched?
+          return [response.status, response.headers, []]
+        end
       end
+      @default_app.call(env)
     end
   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
+
+  # Returns a new variable
+  def variable(*args)
+    Variable.new(self, *args)
+  end
+  
+  # Returns a new glob
+  def glob(*args)
+    Glob.new(self, *args)
+  end
 
   private
 

data/spec/generate_spec.rb

@@ -32,21 +32,59 @@ describe "HttpRouter#generate" 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).compile
-      @router.url(:test, 'html').should == '/test.html'
+    
+    it "should generate with multiple dynamics" do
+      @router.add("/:var/:baz").name(:test).compile
+      @router.url(:test, 'one', 'two').should == '/one/two'
+      @router.url(:test, :var => 'one', :baz => 'two').should == '/one/two'
     end
 
-    it "should generate with a format as a hash" do
-      @router.add("/test.:format").name(:test).compile
-      @router.url(:test, :format => 'html').should == '/test.html'
-    end
+    context "with a :format" do
+      it "should generate with a format" do
+        @router.add("/test.:format").name(:test).compile
+        @router.url(:test, 'html').should == '/test.html'
+      end
 
-    it "should generate with an optional format" do
-      @router.add("/test(.:format)").name(:test).compile
-      @router.url(:test, 'html').should == '/test.html'
-      @router.url(:test).should == '/test'
+      it "should generate with a format as a hash" do
+        @router.add("/test.:format").name(:test).compile
+        @router.url(:test, :format => 'html').should == '/test.html'
+      end
+      
+      it "should generate with format as a symbol" do
+        @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).compile
+        @router.url(:test, 'html').should == '/test.html'
+        @router.url(:test).should == '/test'
+      end
+      
+      it "should generate a dynamic path and a format" do
+        @router.add("/:var1.:format").name(:test).compile
+        @router.url(:test, 'var', :format => 'html').should == '/var.html'
+      end
+      
+      it "should generate a dynamic path and an optional format" do
+        @router.add("/:var1(.:format)").name(:test).compile
+        @router.url(:test, 'var').should == '/var'
+        @router.url(:test, 'var', :format => 'html').should == '/var.html'
+      end
+      
+      it "should generate multiple dynamics and a format" do
+        @router.add("/:foo/:bar.:format").name(:test).compile
+        @router.url(:test, 'var', 'baz', 'html').should == '/var/baz.html'
+        @router.url(:test, :foo => 'var', :bar => 'baz', :format => 'html').should == '/var/baz.html'
+      end
+      
+      it "should generate multiple dynamics and an optional format" do
+        @router.add("/:foo/:bar(.:format)").name(:test).compile
+        @router.url(:test, 'var', 'baz').should == '/var/baz'
+        @router.url(:test, 'var', 'baz', 'html').should == '/var/baz.html'
+        @router.url(:test, :foo => 'var', :bar => 'baz').should == '/var/baz'
+        @router.url(:test, :foo => 'var', :bar => 'baz', :format => 'html').should == '/var/baz.html'
+      end
     end
 
     context "with optional parts" do
@@ -58,7 +96,38 @@ describe "HttpRouter#generate" do
         @router.url(:test, :var1 => 'var', :var2 => 'fooz').should == '/var/fooz'
         proc{@router.url(:test, :var2 => 'fooz').should == '/var/fooz'}.should raise_error(HttpRouter::UngeneratableRouteException)
       end
+      it "should generate with a format" do
+        @router.add("/:var1(/:var2.:format)").name(:test).compile
+        @router.url(:test, 'var').should == '/var'
+        @router.url(:test, 'var', 'fooz', 'html').should == '/var/fooz.html'
+        @router.url(:test, :var1 => 'var').should == '/var'
+        @router.url(:test, :var1 => 'var', :var2 => 'fooz', :format => 'html').should == '/var/fooz.html'
+      end
+      it "should generate with an embeded optional" do
+        @router.add("/:var1(/:var2(/:var3))").name(:test).compile
+        @router.url(:test, 'var').should == '/var'
+        @router.url(:test, 'var', 'fooz').should == '/var/fooz'
+        @router.url(:test, 'var', 'fooz', 'baz').should == '/var/fooz/baz'
+        @router.url(:test, :var1 => 'var').should == '/var'
+        @router.url(:test, :var1 => 'var', :var2 => 'fooz', :var3 => 'baz').should == '/var/fooz/baz'
+      end
+
+      it "should support optional plus optional format" do
+        @router.add("/:var1(/:var2)(.:format)").name(:test).compile
+        @router.url(:test, 'var').should == '/var'
+        @router.url(:test, 'var', 'fooz').should == '/var/fooz'
+        @router.url(:test, 'var', 'fooz', 'html').should == '/var/fooz.html'
+        @router.url(:test, :var1 => 'var').should == '/var'
+        @router.url(:test, :var1 => 'var', :var2 => 'fooz', :format => 'html').should == '/var/fooz.html'
+        @router.url(:test, :var1 => 'var', :format => 'html').should == '/var.html'
+      end
     end
 
+    context "with default values" do
+      it "should generate with all params" do
+        @router.add("/:var").default(:page => 1).name(:test).compile
+        @router.url(:test, 123).should == "/123?page=1"
+      end
+    end
   end
 end

data/spec/misc_spec.rb

@@ -0,0 +1,38 @@
+describe "HttpRouter" do
+  before(:each) do
+    @router = HttpRouter.new
+  end
+
+  context "route adding" do
+    it "should work with options too" do
+      route = @router.add('/:test', :conditions => {:request_method => %w{HEAD GET}, :host => 'host1'}, :default_values => {:page => 1}, :matching => {:test => /^\d+/}).to :test
+      @router.recognize(Rack::MockRequest.env_for('http://host2/variable', :method => 'POST')).matched?.should be_false
+      @router.recognize(Rack::MockRequest.env_for('http://host1/variable', :method => 'POST')).matched?.should be_false
+      @router.recognize(Rack::MockRequest.env_for('http://host2/123', :method => 'POST')).matched?.should be_false
+      @router.recognize(Rack::MockRequest.env_for('http://host1/123', :method => 'POST')).matched?.should be_false
+      @router.recognize(Rack::MockRequest.env_for('http://host1/123', :method => 'GET')).route.dest.should == :test
+    end
+  end
+
+  context "instance_eval block" do
+    HttpRouter.new {
+      add('/test').to :test
+    }.recognize(Rack::MockRequest.env_for('/test', :method => 'GET')).dest.should == :test
+  
+  end
+  
+  context "exceptions" do
+    it "should be smart about multiple optionals" do
+      proc {@router.add("/:var1(/:var2)(/:var3)").compile}.should raise_error(HttpRouter::AmbiguousRouteException)
+    end
+
+    it "should raise on identical variable name" do
+      proc {@router.add("/:var1(/:var1)(/:var1)").compile}.should raise_error(HttpRouter::AmbiguousVariableException)
+    end
+
+    it "should raise on unsupported request methods" do
+      proc {@router.add("/").condition(:flibberty => 'gibet').compile}.should raise_error(HttpRouter::UnsupportedRequestConditionError)
+    end
+
+  end
+end

data/spec/rack/dispatch_spec.rb

@@ -1,7 +1,7 @@
 route_set = HttpRouter.new
 route_set.extend(CallWithMockRequestMixin)
 
-describe "Usher (for rack) route dispatching with redirect_on_trailing_delimiters" do
+describe "HttpRouter route dispatching with redirect_on_trailing_delimiters" do
   before(:each) do
     @route_set = HttpRouter.new(:redirect_trailing_slash => true)
     @route_set.extend(CallWithMockRequestMixin)
@@ -16,7 +16,7 @@ describe "Usher (for rack) route dispatching with redirect_on_trailing_delimiter
 
 end
 
-describe "Usher (for rack) route dispatching" do
+describe "HttpRouter route dispatching" do
   before(:each) do
     route_set.reset!
     @app = MockApp.new("Hello World!")

data/spec/rack/generate_spec.rb

@@ -1,7 +1,7 @@
 route_set = HttpRouter.new
 route_set.extend(CallWithMockRequestMixin)
 
-describe "Usher (for rack) route generation" do
+describe "HttpRouter route generation" do
   before(:each) do
     route_set.reset!
     @app = MockApp.new("Hello World!")

data/spec/recognize_spec.rb

@@ -29,6 +29,15 @@ describe "HttpRouter#recognize" do
       end
     end
 
+    context("proc acceptance") do
+      it "should match optionally with a proc" do
+        route = @router.add("/:test").matching(:test => /^\d+/).matching(:test => proc{|env, val| val == '123' or raise}).to(:test)
+        response = @router.recognize(Rack::MockRequest.env_for('/123'))
+        response.route.should == route
+        response.params_as_hash[:test].should == '123'
+      end
+    end
+
     context("trailing slashes") do
       it "should ignore a trailing slash" do
         route = @router.add("/test").to(:test)
@@ -75,11 +84,17 @@ describe "HttpRouter#recognize" do
 
     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).to(:test1)
-      @router.post("/test").request_method('POST').name(:test_post).to(:test2)
+      @router.post("/test").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
 
+    it "should try both specific and non-specifc routes" do
+      @router.post("/test").host('host1').to(:post_host1)
+      @router.add("/test").host('host2').to(:any_post2)
+      @router.recognize(Rack::MockRequest.env_for('http://host2/test', :method => 'POST')).dest.should == :any_post2
+    end
+
   end
 
   context("dynamic paths") do
@@ -161,11 +176,19 @@ describe "HttpRouter#recognize" do
       response.route.should == route
       response.params_as_hash[:variable].should == 'value'
     end
+
+    it "should recognize interstitial variables with a regex" do
+      route = @router.add('/one-:variable-time').matching(:variable => /^\d+/).to(:test)
+      @router.recognize(Rack::MockRequest.env_for('/one-value-time')).should be_nil
+      response = @router.recognize(Rack::MockRequest.env_for('/one-123-time'))
+      response.route.should == route
+      response.params_as_hash[:variable].should == '123'
+    end
   end
 
   context("dynamic greedy paths") do
     it "should recognize greedy variables" do
-      route = @router.add('/:variable').matching(:variable, /\d+/).to(:test)
+      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']

data/spec/sinatra/recognize_spec.rb

@@ -1,7 +1,7 @@
 require "sinatra"
-require "http_router/sinatra"
+require "http_router/interface/sinatra"
 
-describe "Usher (for Sinatra) route recognition" do
+describe "HttpRouter (for Sinatra) route recognition" do
   before(:each) do
     @app = Sinatra.new { register HttpRouter::Interface::Sinatra::Extension }
     @app.extend(CallWithMockRequestMixin)