http_router 0.4.1 → 0.5.0

data/test/test_variable.rb

@@ -0,0 +1,108 @@
+class TestVariable < MiniTest::Unit::TestCase
+  def test_variable
+    assert_route ':one',      '/two',        {:one => 'two'}
+    assert_route 'test/:one', '/test/three', {:one => 'three'}
+  end
+
+  def test_variable_vs_static
+    dynamic, static = router { add ':one'; add 'one' }
+    assert_route dynamic, '/two', {:one => 'two'}
+    assert_route static,  '/one'
+  end
+
+  def test_variable_with_static_after
+    variable, static = router { 
+      add '/:var/one'
+      add 'one'
+    }
+    assert_route variable,     '/two/one', {:var => 'two'}
+    assert_route static,       '/one'
+    assert_route nil,          '/two'
+  end
+  
+  def test_variable_and_static
+    dynamic, static = router {
+      add("/foo/:id")
+      add("/foo")
+    }
+    assert_route dynamic, '/foo/id', {:id => 'id'}
+    assert_route static,  '/foo'
+  end
+
+  def test_anonymous_variable
+    assert_route '/foo/:',  '/foo/id', {:'$1' => 'id'}
+    assert_route 'foo/:/:', '/foo/id/what', {:'$1' => 'id', :'$2' => 'what'}
+    assert_route 'foo/*/test', '/foo/id1/id2/test', {:'$1' => ['id1', 'id2']}
+    assert_route '/foo/*/what/:', '/foo/id1/id2/what/more', {:'$1' => ['id1', 'id2'], :'$2' => 'more'}
+  end
+
+  def test_variable_mixed_with_static
+    static, dynamic = router {
+      add("/foo/foo")
+      add("/:foo/foo2")
+    }
+    assert_route dynamic, '/foo/foo2', {:foo => 'foo'}
+    assert_route static,  '/foo/foo'
+  end
+
+  def test_encoding
+    assert_route '/:var', '/%E6%AE%BA%E3%81%99', {:var => "\346\256\272\343\201\231"}
+  end
+
+  def test_match_path
+    r = router { add('/:test').match_path(%r{/(test123|\d+)}) }
+    assert_route r, '/test123', {:test => "test123"}
+    assert_route r, '/123', {:test => "123"}
+    assert_route nil, '/test123andmore'
+    assert_route nil, '/lesstest123'
+  end
+
+  def test_format
+    assert_route '/test.:format', '/test.html', {:format => 'html'}
+  end
+
+  def test_optional_format
+    r = router {add('/test(.:format)')}
+    assert_route r, '/test.html', {:format => 'html'}
+    assert_route r, '/test'
+  end
+
+  def test_bare_optional_format
+    r = router {add('(.:format)')}
+    assert_route r, '/.html', {:format => 'html'}
+    assert_route r, '/'
+  end
+
+  def test_var_with_format
+    assert_route '/:test.:format', '/foo.bar', {:test => 'foo', :format => 'bar'}
+  end
+
+  def test_var_with_optional_format
+    r = router { add('/:test(.:format)') }
+    assert_route r, '/foo.bar', {:test => 'foo', :format => 'bar'}
+    assert_route r, '/foo', {:test => 'foo'}
+  end
+
+  def test_glob
+    assert_route '/test/*variable', 'test/one/two/three', {:variable => ['one', 'two', 'three']}
+  end
+
+  def test_glob_with_static
+    assert_route '/test/*variable/test', '/test/one/two/three/test', {:variable => ['one', 'two', 'three']}
+  end
+  
+  def test_glob_with_regex
+    r = router { add('/test/*variable/anymore')}
+    assert_route r, '/test/123/345/567/anymore', {:variable => ['123', '345', '567']}
+    assert_route nil, '/test/123/345/567'
+  end
+  
+  def test_regex_and_greedy
+    with_regex, without_regex = router {
+      add("/:common_variable/:matched").matching(:matched => /\d+/)
+      add("/:common_variable/:unmatched")
+    }
+    assert_route with_regex,    '/common/123',   {:common_variable => 'common', :matched => '123'}
+    assert_route without_regex, '/common/other', {:common_variable => 'common', :unmatched => 'other'}
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: http_router
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 11
   prerelease: false
   segments: 
   - 0
-  - 4
-  - 1
-  version: 0.4.1
+  - 5
+  - 0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Joshua Hull
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-18 00:00:00 -07:00
+date: 2010-12-06 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,7 +51,7 @@ dependencies:
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: minitest
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
@@ -123,9 +123,23 @@ dependencies:
   type: :development
   version_requirements: *id007
 - !ruby/object:Gem::Dependency 
-  name: bundler
+  name: phocus
   prerelease: false
   requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -137,7 +151,7 @@ dependencies:
         - 0
         version: 1.0.0
   type: :development
-  version_requirements: *id008
+  version_requirements: *id009
 description: This library allows you to recognize and build URLs in a Rack application. As well it contains an interface for use within Sinatra.
 email: joshbuddy@gmail.com
 executables: []
@@ -182,22 +196,27 @@ files:
 - lib/http_router/rack.rb
 - lib/http_router/rack/builder.rb
 - lib/http_router/rack/url_map.rb
-- lib/http_router/response.rb
 - lib/http_router/root.rb
 - lib/http_router/route.rb
+- lib/http_router/static.rb
 - lib/http_router/variable.rb
 - lib/http_router/version.rb
-- spec/generate_spec.rb
-- spec/misc_spec.rb
-- spec/mounting_spec.rb
-- spec/rack/dispatch_spec.rb
-- spec/rack/generate_spec.rb
-- spec/rack/middleware_spec.rb
-- spec/rack/route_spec.rb
-- spec/rack/urlmap_spec.rb
-- spec/recognize_spec.rb
-- spec/sinatra/recognize_spec.rb
-- spec/spec_helper.rb
+- test/helper.rb
+- test/rack/test_dispatch.rb
+- test/rack/test_route.rb
+- test/rack/test_urlmap.rb
+- test/sinatra/recognize_spec.rb
+- test/sinatra/test_recognize.rb
+- test/test_arbitrary.rb
+- test/test_generate.rb
+- test/test_greedy.rb
+- test/test_interstitial.rb
+- test/test_misc.rb
+- test/test_mounting.rb
+- test/test_recognize.rb
+- test/test_request.rb
+- test/test_trailing_slash.rb
+- test/test_variable.rb
 has_rdoc: true
 homepage: http://github.com/joshbuddy/http_router
 licenses: []
@@ -232,15 +251,5 @@ rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A kick-ass HTTP router for use in Rack & Sinatra
-test_files: 
-- spec/generate_spec.rb
-- spec/misc_spec.rb
-- spec/mounting_spec.rb
-- spec/rack/dispatch_spec.rb
-- spec/rack/generate_spec.rb
-- spec/rack/middleware_spec.rb
-- spec/rack/route_spec.rb
-- spec/rack/urlmap_spec.rb
-- spec/recognize_spec.rb
-- spec/sinatra/recognize_spec.rb
-- spec/spec_helper.rb
+test_files: []
+

data/lib/http_router/response.rb

@@ -1,46 +0,0 @@
-class HttpRouter
-  module Response
-    def self.matched(*args)
-      Matched.new(*args)
-    end
-
-    def self.unmatched(*args)
-      Unmatched.new(*args)
-    end
-
-    private
-    class Unmatched < Struct.new(:status, :headers)
-      def matched?
-        false
-      end
-    end
-
-    class Matched < Struct.new(:path, :params, :matched_path, :remaining_path)
-      attr_reader :params_as_hash, :route
-
-      def initialize(path, params, matched_path, remaining_path = nil)
-        raise if matched_path.nil?
-        super
-        path.splitting_indexes and path.splitting_indexes.each{|i| params[i] = params[i].split(HttpRouter::Parts::SLASH_RX)}
-        @params_as_hash = path.hashify_params(params)
-      end
-
-      def matched?
-        true
-      end
-
-      def route
-        path.route
-      end
-
-      def dest
-        route.dest
-      end
-      alias_method :destination, :dest
-
-      def partial_match?
-        route.partially_match?
-      end
-    end
-  end
-end

data/spec/generate_spec.rb

@@ -1,234 +0,0 @@
-require 'spec_helper'
-describe "HttpRouter#generate" do
-  before(:each) do
-    @router = HttpRouter.new
-  end
-
-  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).compile
-        @router.url(route).should == path
-      end
-    end
-  end
-
-  context("dynamic paths") do
-    it "should generate from a hash" do
-      @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).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 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
-
-    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 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
-      it "should generate both" do
-        @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'
-        @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
-
-    context "with nil values" do
-      it "shouldn't use nil values" do
-        @router.add("/url(/:var)").name(:test).compile
-        @router.url(:test, :var => nil).should == "/url"
-      end
-    end
-
-    context "with a matching" do
-      it "should raise an exception when the route is invalid" do
-        @router.add("/:var").matching(:var => /\d+/).name(:test).compile
-        proc{@router.url(:test, 'asd')}.should raise_error(HttpRouter::InvalidRouteException)
-      end
-    end
-
-    context "url mounting" do
-      context "nested routes" do
-        before(:each) do
-          @r1 = HttpRouter.new
-          @r2 = HttpRouter.new
-          @r2.add("/bar").name(:test).compile
-        end
-
-        it "should set the url mount on a child route" do
-          route = @r1.add("/foo").to(@r2)
-          @r2.url_mount.url.should == "/foo"
-          @r2.url(:test).should == "/foo/bar"
-        end
-
-        it "should set any default values on the url mount" do
-          route = @r1.add("/foo/:bar").default(:bar => "baz").to(@r2)
-          @r2.url(:test).should == "/foo/baz/bar"
-          @r2.url(:test, :bar => "haha").should == "/foo/haha/bar"
-        end
-
-        it "should use multiple variables" do
-          @r1.add("/foo/:bar/:baz").default(:bar => "bar").to(@r2)
-          @r2.url(:test, :baz => "baz").should == "/foo/bar/baz/bar"
-        end
-
-        it "should not steal parameters from the defaults it doesn't need" do
-          route = @r1.add("/foo/:bar").default(:bar => "baz").to(@r2)
-          @r2.url(:test, :bang => "ers").should == "/foo/baz/bar?bang=ers"
-          @r2.url(:test, :bar => "haha", :bang => "ers").should == "/foo/haha/bar?bang=ers"
-        end
-
-        it "should generate on a path with an optional variable" do
-          @r1.add("/foo(/:bar)").to(@r2)
-          @r2.add("/hey(/:there)").name(:test).compile
-          @r2.url(:test).should == "/foo/hey"
-          @r2.url(:test, :bar => "bar").should == "/foo/bar/hey"
-          @r2.url(:test, :bar => "bar", :there => "there").should == "/foo/bar/hey/there"
-        end
-
-        it "should nest 3 times deeply" do
-          @r3 = HttpRouter.new
-          @r1.add("/foo(/:bar)").default(:bar => "barry").to(@r2)
-          @r2.add("/hi").name(:hi).compile
-          @r2.add("/mounted").to(@r3)
-          @r3.add("/endpoint").name(:endpoint).compile
-
-          @r2.url(:hi).should == "/foo/barry/hi"
-          @r3.url(:endpoint).should == "/foo/barry/mounted/endpoint"
-          @r3.url(:endpoint, :bar => "flower").should == "/foo/flower/mounted/endpoint"
-        end
-
-        it "should allow me to set the host via a default" do
-          @r1.add("/mounted").default(:host => "example.com").to(@r2)
-          @r2.url(:test).should == "http://example.com/mounted/bar"
-        end
-
-        it "should allow me to set the host via an option" do
-          @r1.add("/mounted").to(@r2)
-          @r2.url(:test).should == "/mounted/bar"
-          @r2.url(:test, :host => "example.com").should == "http://example.com/mounted/bar"
-        end
-
-        it "should allow me to set the scheme via an option" do
-          @r1.add("/mounted").to(@r2)
-          @r2.url(:test).should == "/mounted/bar"
-          @r2.url(:test, :scheme => "https", :host => "example.com").should == "https://example.com/mounted/bar"
-        end
-
-        it "should clone my nested structure" do
-          @r3 = HttpRouter.new
-          @r1.add("/first").to(@r2)
-          @r2.add("/second").to(@r3)
-          r1 = @r1.clone
-          @r1.routes.first.should_not be_nil
-          r2 = r1.routes.first.dest
-          r2.should_not be_nil
-          @r1.routes.first.dest.object_id.should == @r2.object_id
-          r2.object_id.should_not == @r2.object_id
-          r2.routes.should have(2).route
-          r3 = r2.routes.last.dest
-          r3.should be_an_instance_of(HttpRouter)
-          r3.object_id.should_not == @r3.object_id
-        end
-      end
-    end
-  end
-end

data/spec/misc_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-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+/}, :name => :foobar).to :test
-      @router.recognize(Rack::MockRequest.env_for('http://host2/variable', :method => 'POST')).should be_nil
-      @router.recognize(Rack::MockRequest.env_for('http://host1/variable', :method => 'POST')).should be_nil
-      @router.recognize(Rack::MockRequest.env_for('http://host2/123',      :method => 'POST')).should be_nil
-      @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
-      @router.url(:foobar, '123').should == '/123?page=1'
-    end
-  end
-
-  context "instance_eval block" do
-    it "run the routes" do
-      HttpRouter.new {
-        add('/test').to :test
-      }.recognize(Rack::MockRequest.env_for('/test', :method => 'GET')).dest.should == :test
-    end
-  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
-
-  context "cloning" do
-    it "clone the routes" do
-      r1 = HttpRouter.new {
-        add('/test').name(:test_route).to :test
-      }
-      r2 = r1.clone
-
-      r2.add('/test2').name(:test).to(:test2)
-      r2.routes.size.should == 2
-
-      r1.recognize(Rack::MockRequest.env_for('/test2')).should be_nil
-      r2.recognize(Rack::MockRequest.env_for('/test2')).should_not be_nil
-      r1.named_routes[:test_route].should == r1.routes.first
-      r2.named_routes[:test_route].should == r2.routes.first
-
-      r1.add('/another').name(:test).to(:test2)
-
-      r1.routes.size.should == r2.routes.size
-      r1.url(:test).should == '/another'
-      r2.url(:test).should == '/test2'
-      r1.routes.first.dest.should == :test
-      r2.routes.first.dest.should == :test
-    end
-  end
-end

data/spec/mounting_spec.rb

@@ -1,5 +0,0 @@
-describe "mounting" do
-  before(:each) do
-    @router = HttpRouter.new
-  end
-end