http_router 0.10.2 → 0.11.0

data/lib/http_router/util.rb

@@ -1,41 +1,5 @@
 class HttpRouter
   module Util
-    def self.add_path_generation(target, route, path, path_validation_regex = nil)
-      regex_parts = path.split(/([:\*][a-zA-Z0-9_]+)/)
-      regex, code = '', ''
-      dynamic = false
-      regex_parts.each_with_index do |part, index|
-        case part[0]
-        when ?:, ?*
-          if index != 0 && regex_parts[index - 1][-1] == ?\\
-            regex << Regexp.quote(part) unless path_validation_regex
-            code << part
-            dynamic = true
-          else
-            regex << (route.matches_with[part[1, part.size].to_sym] || '.*?').to_s unless path_validation_regex
-            code << "\#{args.shift || (options && options.delete(:#{part[1, part.size]})) || return}"
-            dynamic = true
-          end
-        else
-          regex << Regexp.quote(part) unless path_validation_regex
-          code << part
-        end
-      end
-      path_validation_regex ||= Regexp.new("^#{regex}$") if dynamic
-      if path_validation_regex
-        target.instance_eval <<-EOT, __FILE__, __LINE__ + 1
-        def raw_url(args, options)
-          url = \"#{code}\"
-          #{path_validation_regex.inspect}.match(url) ? url : nil
-        end
-        EOT
-      else
-        target.instance_eval <<-EOT, __FILE__, __LINE__ + 1
-        def raw_url(args, options)
-          \"#{code}\"
-        end
-        EOT
-      end
-    end
+
   end
 end

data/lib/http_router/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 class HttpRouter #:nodoc
-  VERSION = '0.10.2'
+  VERSION = '0.11.0'
 end

data/test/common/generate.txt

@@ -1,6 +1,6 @@
 {"a": "/:var"}
 	["/test", "a", {"var":"test"}]
-#	["/test", "a", ["test"]]
+	["/test", "a", ["test"]]
 
 {"a": "/"}
 {"b": "/test"}

data/test/generation.rb

@@ -2,18 +2,22 @@ require 'json'
 require "#{File.dirname(__FILE__)}/generic"
 class GenerationTest < AbstractTest
   def run_tests
-    @tests.map(&:case).each do |(expected_result, name, args)|
-      args = [args] unless args.is_a?(Array)
-      args.compact!
-      args.map!{|a| a.is_a?(Hash) ? Hash[a.map{|k,v| [k.to_sym, v]}] : a }
-      result = begin
-        @router.url(name.to_sym, *args)
-      rescue HttpRouter::InvalidRouteException
-        nil
-      rescue HttpRouter::MissingParameterException
-        nil
+    @tests.map(&:case).each do |(expected_result, name, oargs)|
+      oargs = [oargs] unless oargs.is_a?(Array)
+      oargs.compact!
+      oargs.map!{|a| a.is_a?(Hash) ? Hash[a.map{|k,v| [k.to_sym, v]}] : a }
+      [[:path, ''], [:url_ns, '://localhost'], [:url, 'http://localhost']].each do |(meth, prefix)|
+        args = oargs.map{|o| o.dup rescue o}
+        result = begin
+          path = @router.send(meth, name.to_sym, *args.dup)
+          path
+        rescue HttpRouter::InvalidRouteException
+          nil
+        rescue HttpRouter::MissingParameterException
+          nil
+        end
+        error("Result #{result.inspect} did not match expectation #{expected_result.inspect}") unless result == (expected_result ? prefix + expected_result : expected_result)
       end
-      error("Result #{result.inspect} did not match expectation #{expected_result.inspect}") unless result == expected_result
     end
     print '.'
   end

data/test/generic.rb

@@ -83,11 +83,11 @@ class AbstractTest
     @routes.case.each do |route_definition|
       error("Too many keys! #{route_definition.keys.inspect}") unless route_definition.keys.size == 1
       route_name, route_properties = route_definition.keys.first, route_definition.values.first
+      opts = {:name => route_name.to_sym}
       route = case route_properties
       when String
-        @router.add(route_properties)
+        @router.add(route_properties, opts)
       when Hash
-        opts = {}
         route_path = interpret_val(route_properties.delete("path"))
         if route_properties.key?("conditions")
           opts[:conditions] = Hash[route_properties.delete("conditions").map{|k, v| [k.to_sym, interpret_val(v)]}]
@@ -102,7 +102,6 @@ class AbstractTest
       else
         error("Route isn't a String or hash")
       end
-      route.name(route_name.to_sym)
       route.to{|env| [200, {"env-to-test" => env.dup}, [route_name]]}
     end
     run_tests

data/test/helper.rb

@@ -2,18 +2,20 @@
 require 'minitest/autorun'
 require 'phocus'
 
-class HttpRouter::Route
-  def default_destination
-    to{|env| Rack::Response.new("Routing to #{to_s}").finish}
+class HttpRouter
+  module RouteHelper
+    def default_destination
+      to proc {|env| ::Rack::Response.new("Routing to #{object_id}").finish}
+      self
+    end
   end
 end
 
 class MiniTest::Unit::TestCase
-
   def router(opts = nil, &blk)
     @router ||= HttpRouter.new(opts, &blk)
     if blk
-      @router.routes.each { |route| route.default_destination if route.dest.nil? }
+      @router.routes.each { |route| route.dest ||= proc {|env| Rack::Response.new("Routing to #{route.object_id}").finish} }
       @router.routes.size > 1 ? @router.routes : @router.routes.first
     else
       @router
@@ -44,15 +46,18 @@ class MiniTest::Unit::TestCase
   end
 
   def assert_route(route, request, params = nil, &blk)
-    if route.is_a?(String)
+    route = case route
+    when String
       router.reset!
-      route = router.add(route)
+      router.add(route)
+    else
+      route
     end
-    dest = "Routing to #{route.to_s}"
-    route.to{|env| Rack::Response.new(dest).finish} if route && route.dest.nil?
+    route.default_destination if route && route.dest.nil?
     request = Rack::MockRequest.env_for(request) if request.is_a?(String)
     response = @router.call(request)
     if route
+      dest = "Routing to #{route.object_id}"
       assert_equal [dest], response.last.body
       if params
         raise "Params was nil, but you expected params" if request['router.params'].nil?
@@ -72,6 +77,6 @@ class MiniTest::Unit::TestCase
       route = router.add(route)
     end
     route.to{|env| Rack::Response.new("Routing to #{route.to_s}").finish} if route && route.respond_to?(:to) && !route.dest
-    assert_equal path.gsub('[','%5B').gsub(']','%5D'), router.url(route, *args)
+    assert_equal path.gsub('[','%5B').gsub(']','%5D'), router.path(route, *args)
   end
 end

data/test/rack/test_route.rb

@@ -26,11 +26,6 @@ class TestRouteExtensions < MiniTest::Unit::TestCase
     assert_equal __FILE__, body.path
   end
 
-  def test_chainable
-    router.get("/index.html").redirect("/").name(:root)
-    assert_equal "/index.html", router.url(:root)
-  end
-
   def test_custom_status
     router.get("/index.html").redirect("/", 303)
     response = router.call(Rack::MockRequest.env_for("/index.html"))

data/test/test_misc.rb

@@ -1,36 +1,41 @@
 class TestMisc < MiniTest::Unit::TestCase
+
   def test_cloning
-    r1 = HttpRouter.new { add('/test').name(:test_route).to(:test) }
+    r1 = HttpRouter.new { add('/test', :name => :test_route).to(:test) }
     r2 = r1.clone
 
-    r2.add('/test2').name(:test).to(:test2)
+    r2.add('/test2', :name => :test).to(:test2)
     assert_equal 2, r2.routes.size
 
-    assert_equal nil, r1.recognize(Rack::Request.new(Rack::MockRequest.env_for('/test2')))
-    assert r2.recognize(Rack::MockRequest.env_for('/test2'))
-    assert_equal r1.routes.first, r1.named_routes[:test_route].first
-    assert_equal r2.routes.first, r2.named_routes[:test_route].first
+    matches, other_methods = r1.recognize(Rack::Request.new(Rack::MockRequest.env_for('/test2')))
+    assert_equal nil, matches
+    assert r2.recognize(Rack::MockRequest.env_for('/test2')).first
+    assert_equal r1.routes.size, 1
+    assert_equal r2.routes.size, 2
 
-    r1.add('/another').name(:test).to(:test2)
+    r1.add('/another', :name => :test).to(:test2)
 
     assert_equal r1.routes.size, r2.routes.size
-    assert_equal '/another', r1.url(:test)
-    assert_equal '/test2',   r2.url(:test)
+    assert_equal '/another', r1.path(:test)
+    assert_equal '/test2',   r2.path(:test)
     assert_equal :test, r1.routes.first.dest
     assert_equal :test, r2.routes.first.dest
   end
 
   def test_reseting
-    r = HttpRouter.new { add('/hi').to(:test) }
-    assert r.recognize(Rack::MockRequest.env_for('/hi'))
-    r.reset!
-    assert !r.recognize(Rack::MockRequest.env_for('/hi'))
+    router = HttpRouter.new
+    r = router.add('/hi').to(:test)
+    matches, other_methods = router.recognize(Rack::MockRequest.env_for('/hi'))
+    assert_equal r, matches.first.route
+    router.reset!
+    assert_equal nil, router.recognize(Rack::MockRequest.env_for('/hi')).first
   end
 
   def test_redirect_trailing_slash
     r = HttpRouter.new(:redirect_trailing_slash => true) { add('/hi').to(:test) }
-    response = r.recognize(Rack::MockRequest.env_for('/hi/'))
-    assert_equal nil, response
+    response = r.call(Rack::MockRequest.env_for('/hi/'))
+    assert_equal 302, response.first
+    assert_equal '/hi', response[1]['Location']
   end
 
   def test_multi_recognize
@@ -41,41 +46,45 @@ class TestMisc < MiniTest::Unit::TestCase
       add('/:var1/there')
     }
     response = router.recognize(Rack::MockRequest.env_for('/hi/there'))
-    assert_equal [r1, r2, r3, r4], response.map{|resp| resp.path.route}
+    assert_equal [r1, r2, r3, r4], response.first.map{|resp| resp.path.route}
     response = router.recognize(Rack::MockRequest.env_for('/hi/var'))
-    assert_equal [r2, r3], response.map{|resp| resp.path.route}
+    assert_equal [r2, r3], response.first.map{|resp| resp.path.route}
     response = router.recognize(Rack::MockRequest.env_for('/you/there'))
-    assert_equal [r2, r4], response.map{|resp| resp.path.route}
+    assert_equal [r2, r4], response.first.map{|resp| resp.path.route}
   end
 
   def test_multi_name_gen
-    r = HttpRouter.new
-    r.add('/').name(:index).default_destination
-    r.add('/:name').name(:index).default_destination
-    r.add('/:name/:category').name(:index).default_destination
-    assert_equal '/', r.url(:index)
-    assert_equal '/name', r.url(:index, 'name')
-    assert_equal '/name/category', r.url(:index, 'name', 'category')
+    r = router
+    r.add('/', :name => :index).default_destination
+    r.add('/:name', :name => :index).default_destination
+    r.add('/:name/:category', :name => :index).default_destination
+    assert_equal '/', r.path(:index)
+    assert_equal '/name', r.path(:index, 'name')
+    assert_equal '/name/category', r.path(:index, 'name', 'category')
   end
 
-  def test_regex_generation
+  def test_yielding_from_recognize
     r = HttpRouter.new
-    r.add(%r|/test/.*|, :path_for_generation => '/test/:variable').name(:route).default_destination
-    assert_equal '/test/var', r.url(:route, "var")
+    r1 = r.add('/:name').default_destination
+    r2 = r.add('/:name').default_destination
+    r3 = r.add('/:name').default_destination
+    matches = []
+    r.recognize(Rack::MockRequest.env_for('/test')) { |r| matches << r.route }
+    assert_equal [r1, r2, r3], matches
   end
 
-  def test_too_many_params
-    r = HttpRouter.new
-    r.add(%r|/test/.*|, :path_for_generation => '/test/:variable').name(:route).default_destination
-    assert_equal '/test/var', r.url(:route, "var")
-    assert_equal '/test/var', r.url(:route, :variable => "var")
-    assert_raises(HttpRouter::InvalidRouteException) { r.url(:route) }
+  def test_regex_generation
+    r = router
+    r.add(%r|/test/.*|, :path_for_generation => '/test/:variable', :name => :route).default_destination
+    assert_equal '/test/var', r.path(:route, "var")
   end
 
-  def test_too_many_args
-    r = HttpRouter.new
-    r.add('/').name(:route).default_destination
-    assert_raises(HttpRouter::TooManyParametersException) { r.url(:route, "hi") }
+  def test_too_many_params
+    r = router
+    r.add(%r|/test/.*|, :path_for_generation => '/test/:variable', :name => :route).default_destination
+    assert_equal '/test/var', r.path(:route, "var")
+    assert_equal '/test/var', r.path(:route, :variable => "var")
+    assert_raises(HttpRouter::InvalidRouteException) { r.path(:route) }
   end
 
   def test_public_interface
@@ -91,6 +100,7 @@ class TestMisc < MiniTest::Unit::TestCase
     assert methods.include?(:process_destination_path)
     assert methods.include?(:rewrite_partial_path_info)
     assert methods.include?(:rewrite_path_info)
+    assert methods.include?(:extend_route)
   end
 
   def test_to_s_and_inspect
@@ -98,8 +108,8 @@ class TestMisc < MiniTest::Unit::TestCase
     router.add('/').to(:test)
     router.add('/test').to(:test2)
     router.post('/test').to(:test3)
-    assert router.to_s.match(/^#<HttpRouter:0x[0-9a-f]+ number of routes \(3\) ignore_trailing_slash\? \(true\) redirect_trailing_slash\? \(false\) known_methods \(POST\)>$/)
-    assert router.inspect.match(/^#<HttpRouter:0x[0-9a-f]+ number of routes \(3\) ignore_trailing_slash\? \(true\) redirect_trailing_slash\? \(false\) known_methods \(POST\)>/)
+    assert router.to_s.match(/^#<HttpRouter:0x[0-9a-f-]+ number of routes \(3\) ignore_trailing_slash\? \(true\) redirect_trailing_slash\? \(false\)>$/)
+    assert router.inspect.match(/^#<HttpRouter:0x[0-9a-f-]+ number of routes \(3\) ignore_trailing_slash\? \(true\) redirect_trailing_slash\? \(false\)>/)
     assert router.inspect.match(/Path: "\/test" for route unnamed route to :test3/)
   end
 end

data/test/test_mounting.rb

@@ -2,67 +2,68 @@ class TestMounting < MiniTest::Unit::TestCase
   def setup
     @r1 = HttpRouter.new
     @r2 = HttpRouter.new
-    @r2.add("/bar").name(:test).to{|env| [200, {}, []]}
+    @r2.add("/bar", :name => :test).to{|env| [200, {}, []]}
   end
 
   def test_url_mount_for_child_route
     route = @r1.add("/foo").to(@r2)
     assert_equal "/foo", @r2.url_mount.url
-    assert_equal "/foo/bar", @r2.url(:test)
+    assert_equal "/foo/bar", @r2.path(:test)
   end
 
   def test_default_values
-    route = @r1.add("/foo/:bar").default(:bar => "baz").to(@r2)
-    assert_equal "/foo/baz/bar", @r2.url(:test)
-    assert_equal "/foo/haha/bar", @r2.url(:test, :bar => "haha")
+    route = @r1.add("/foo/:bar", :default_values => {:bar => "baz"}).to(@r2)
+    assert_equal "/foo/baz/bar", @r2.path(:test)
+    assert_equal "/foo/haha/bar", @r2.path(:test, :bar => "haha")
   end
 
   def test_multiple_values
-    @r1.add("/foo/:bar/:baz").default(:bar => "bar").to(@r2)
-    assert_equal "/foo/bar/baz/bar", @r2.url(:test, :baz => "baz")
+    @r1.add("/foo/:bar/:baz", :default_values => {:bar => "bar"}).to(@r2)
+    assert_equal "/foo/bar/baz/bar", @r2.path(:test, :baz => "baz")
   end
 
   def test_bubble_params
-    route = @r1.add("/foo/:bar").default(:bar => "baz").to(@r2)
-    assert_equal "/foo/baz/bar?bang=ers",  @r2.url(:test, :bang => "ers")
-    assert_equal "/foo/haha/bar?bang=ers", @r2.url(:test, :bar => "haha", :bang => "ers")
+    route = @r1.add("/foo/:bar", :default_values => {:bar => 'baz'})
+    route.to(@r2)
+    assert_equal "/foo/baz/bar?bang=ers",  @r2.path(:test, :bang => "ers")
+    assert_equal "/foo/haha/bar?bang=ers", @r2.path(:test, :bar => "haha", :bang => "ers")
   end
 
   def test_path_with_optional
     @r1.add("/foo(/:bar)").to(@r2)
-    @r2.add("/hey(/:there)").name(:test2).to{|env| [200, {}, []]}
-    assert_equal "/foo/hey", @r2.url(:test2)
-    assert_equal "/foo/bar/hey", @r2.url(:test2, :bar => "bar")
-    assert_equal "/foo/bar/hey/there", @r2.url(:test2, :bar => "bar", :there => "there")
+    @r2.add("/hey(/:there)", :name => :test2).to{|env| [200, {}, []]}
+    assert_equal "/foo/hey", @r2.path(:test2)
+    assert_equal "/foo/bar/hey", @r2.path(:test2, :bar => "bar")
+    assert_equal "/foo/bar/hey/there", @r2.path(:test2, :bar => "bar", :there => "there")
   end
 
   def test_nest3
     @r3 = HttpRouter.new
-    @r1.add("/foo(/:bar)").default(:bar => "barry").to(@r2)
-    @r2.add("/hi").name(:hi).to{|env| [200, {}, []]}
+    @r1.add("/foo(/:bar)", :default_values => {:bar => 'barry'}).to(@r2)
+    @r2.add("/hi", :name => :hi).to{|env| [200, {}, []]}
     @r2.add("/mounted").to(@r3)
-    @r3.add("/endpoint").name(:endpoint).to{|env| [200, {}, []]}
+    @r3.add("/endpoint", :name => :endpoint).to{|env| [200, {}, []]}
 
-    assert_equal "/foo/barry/hi",                @r2.url(:hi)
-    assert_equal "/foo/barry/mounted/endpoint",  @r3.url(:endpoint)
-    assert_equal "/foo/flower/mounted/endpoint", @r3.url(:endpoint, :bar => "flower")
+    assert_equal "/foo/barry/hi",                @r2.path(:hi)
+    assert_equal "/foo/barry/mounted/endpoint",  @r3.path(:endpoint)
+    assert_equal "/foo/flower/mounted/endpoint", @r3.path(:endpoint, :bar => "flower")
   end
 
   def test_with_default_host
-    @r1.add("/mounted").default(:host => "example.com").to(@r2)
-    assert_equal "http://example.com/mounted/bar", @r2.url(:test)
+    @r1.add("/mounted", :default_values => {:host => "example.com"}).to(@r2)
+    assert_equal "http://example.com/mounted/bar", @r2.path(:test)
   end
 
   def test_with_host
     @r1.add("/mounted").to(@r2)
-    assert_equal "/mounted/bar", @r2.url(:test)
-    assert_equal "http://example.com/mounted/bar", @r2.url(:test, :host => "example.com")
+    assert_equal "/mounted/bar", @r2.path(:test)
+    assert_equal "http://example.com/mounted/bar", @r2.path(:test, :host => "example.com")
   end
 
   def test_with_scheme
     @r1.add("/mounted").to(@r2)
-    assert_equal "/mounted/bar", @r2.url(:test)
-    assert_equal "https://example.com/mounted/bar", @r2.url(:test, :scheme => "https", :host => "example.com")
+    assert_equal "/mounted/bar", @r2.path(:test)
+    assert_equal "https://example.com/mounted/bar", @r2.path(:test, :scheme => "https", :host => "example.com")
   end
 
   def test_clone

data/test/test_recognition.rb

@@ -8,71 +8,6 @@ class TestRecognition < MiniTest::Unit::TestCase
     EOT
   end
 
-  def test_match
-    hello, love80, love8080 = router {
-      add('test').arbitrary(Proc.new{|req, params| req.rack.host == 'hellodooly' })
-      add("test").arbitrary(Proc.new{|req, params| req.rack.host == 'lovelove' }).arbitrary{|req, params| req.rack.port == 80}
-      add("test").arbitrary(Proc.new{|req, params| req.rack.host == 'lovelove' }).arbitrary{|req, params| req.rack.port == 8080}
-    }
-    assert_route love8080, 'http://lovelove:8080/test'
-  end
-
-  def test_less_specific_node
-    hello, love80, love8080, general = router {
-      add("/test").arbitrary(Proc.new{|req, params| req.rack.host == 'hellodooly' })
-      add("/test").arbitrary(Proc.new{|req, params| req.rack.host == 'lovelove' }).arbitrary{|req, params| req.rack.port == 80}
-      add("/test").arbitrary(Proc.new{|req, params| req.rack.host == 'lovelove' }).arbitrary{|req, params| req.rack.port == 8080}
-      add("/test")
-    }
-    assert_route general,  'http://lovelove:8081/test'
-    assert_route hello,    'http://hellodooly:8081/test'
-    assert_route love80,   'http://lovelove:80/test'
-    assert_route love8080, 'http://lovelove:8080/test'
-  end
-
-  def test_match_request
-    love80, love8080 = router {
-      add("/test").get.arbitrary(Proc.new{|req, params| req.rack.host == 'lovelove' }).arbitrary{|req, params| req.rack.port == 80}
-      add("/test").get.arbitrary(Proc.new{|req, params| req.rack.host == 'lovelove' }).arbitrary{|req, params| req.rack.port == 8080}
-    }
-    assert_route love80,   'http://lovelove:80/test'
-    assert_route love8080, 'http://lovelove:8080/test'
-  end
-
-  def test_less_specific_with_request
-    love80, love8080, general = router {
-      add("test").post.arbitrary(Proc.new{|req, params| req.rack.host == 'lovelove' }).arbitrary{|req, params| req.rack.port == 80}
-      add("test").post.arbitrary(Proc.new{|req, params| req.rack.host == 'lovelove' }).arbitrary{|req, params| req.rack.port == 8080}
-      add("test").post
-    }
-    assert_route love8080, Rack::MockRequest.env_for('http://lovelove:8080/test', :method => :post)
-    assert_route love80,   Rack::MockRequest.env_for('http://lovelove:80/test', :method => :post)
-    assert_route general,  Rack::MockRequest.env_for('/test', :method => :post)
-  end
-
-  def test_pass_params
-    r = router {
-      add(":test").get.arbitrary(Proc.new{|req, params, dest| params[:test] == 'test' })
-    }
-    assert_route r, '/test', {:test => 'test'}
-  end
-
-  def test_continue
-    no, yes = router {
-      add('test').arbitrary_with_continue{|req, p| req.continue[false]}
-      add('test').arbitrary_with_continue{|req, p| req.continue[true]}
-    }
-    assert_route yes, '/test'
-  end
-
-  def test_passing
-    passed, working = router {
-      add('/').to { |env| throw :pass; [200, {}, ['pass']] }
-      add('/').to { |env| [200, {}, ['working']] }
-    }
-    assert_body 'working', router.call(Rack::MockRequest.env_for('/'))
-  end
-
   def test_non_path_matching
     passed, working = router {
       add(:conditions => {:user_agent => /MSIE/}).to { |env| [200, {}, ['IE']] }
@@ -90,18 +25,8 @@ class TestRecognition < MiniTest::Unit::TestCase
     assert_body 'working', router.call(Rack::MockRequest.env_for('/'))
   end
 
-  def test_request_mutation
-    got_this_far = false
-    non_matching, matching = router {
-      add("/test/:var/:var2/*glob").matching(:var2 => /123/, :glob => /[a-z]+/).get.arbitrary{|env, params| got_this_far = true; false}
-      add("/test/:var/:var2/*glob").matching(:var2 => /123/, :glob => /[a-z]+/).get
-    }
-    assert_route matching, '/test/123/123/asd/aasd/zxcqwe/asdzxc', {:var => '123', :var2 => '123', :glob => %w{asd aasd zxcqwe asdzxc}}
-    assert got_this_far, "matching should have gotten this far"
-  end
-
   def test_compiling_uncompiling
-    @router = HttpRouter.new
+    @router = router
     root = @router.add('/').default_destination
     assert_route root, '/'
     test = @router.add('/test').default_destination