railscast-assets 0.0.2

data/vendor/bundle/gems/journey-1.0.4/test/route/definition/test_parser.rb

@@ -0,0 +1,108 @@
+require 'helper'
+
+module Journey
+  module Definition
+    class TestParser < MiniTest::Unit::TestCase
+      def setup
+        @parser = Parser.new
+      end
+
+      def test_slash
+        assert_equal :SLASH, @parser.parse('/').type
+        assert_round_trip '/'
+      end
+
+      def test_segment
+        assert_round_trip '/foo'
+      end
+
+      def test_segments
+        assert_round_trip '/foo/bar'
+      end
+
+      def test_segment_symbol
+        assert_round_trip '/foo/:id'
+      end
+
+      def test_symbol
+        assert_round_trip '/:foo'
+      end
+
+      def test_group
+        assert_round_trip '(/:foo)'
+      end
+
+      def test_groups
+        assert_round_trip '(/:foo)(/:bar)'
+      end
+
+      def test_nested_groups
+        assert_round_trip '(/:foo(/:bar))'
+      end
+
+      def test_dot_symbol
+        assert_round_trip('.:format')
+      end
+
+      def test_dot_literal
+        assert_round_trip('.xml')
+      end
+
+      def test_segment_dot
+        assert_round_trip('/foo.:bar')
+      end
+
+      def test_segment_group_dot
+        assert_round_trip('/foo(.:bar)')
+      end
+
+      def test_segment_group
+        assert_round_trip('/foo(/:action)')
+      end
+
+      def test_segment_groups
+        assert_round_trip('/foo(/:action)(/:bar)')
+      end
+
+      def test_segment_nested_groups
+        assert_round_trip('/foo(/:action(/:bar))')
+      end
+
+      def test_group_followed_by_path
+        assert_round_trip('/foo(/:action)/:bar')
+      end
+
+      def test_star
+        assert_round_trip('*foo')
+        assert_round_trip('/*foo')
+        assert_round_trip('/bar/*foo')
+        assert_round_trip('/bar/(*foo)')
+      end
+
+      def test_or
+        assert_round_trip('a|b')
+        assert_round_trip('a|b|c')
+        assert_round_trip('(a|b)|c')
+        assert_round_trip('a|(b|c)')
+        assert_round_trip('*a|(b|c)')
+        assert_round_trip('*a|:b|c')
+      end
+
+      def test_arbitrary
+        assert_round_trip('/bar/*foo#')
+      end
+
+      def test_literal_dot_paren
+        assert_round_trip "/sprockets.js(.:format)"
+      end
+
+      def test_groups_with_dot
+        assert_round_trip "/(:locale)(.:format)"
+      end
+
+      def assert_round_trip str
+        assert_equal str, @parser.parse(str).to_s
+      end
+    end
+  end
+end

data/vendor/bundle/gems/journey-1.0.4/test/route/definition/test_scanner.rb

@@ -0,0 +1,54 @@
+require 'helper'
+
+module Journey
+  module Definition
+    class TestScanner < MiniTest::Unit::TestCase
+      def setup
+        @scanner = Scanner.new
+      end
+
+      # /page/:id(/:action)(.:format)
+      def test_tokens
+        [
+          ['/',      [[:SLASH, '/']]],
+          ['*omg',   [[:STAR, '*'], [:LITERAL, 'omg']]],
+          ['/page',  [[:SLASH, '/'], [:LITERAL, 'page']]],
+          ['/~page', [[:SLASH, '/'], [:LITERAL, '~page']]],
+          ['/pa-ge', [[:SLASH, '/'], [:LITERAL, 'pa-ge']]],
+          ['/:page', [[:SLASH, '/'], [:SYMBOL, ':page']]],
+          ['/(:page)', [
+                        [:SLASH, '/'],
+                        [:LPAREN, '('],
+                        [:SYMBOL, ':page'],
+                        [:RPAREN, ')'],
+                      ]],
+          ['(/:action)', [
+                          [:LPAREN, '('],
+                          [:SLASH, '/'],
+                          [:SYMBOL, ':action'],
+                          [:RPAREN, ')'],
+                         ]],
+          ['(())', [[:LPAREN, '('],
+                   [:LPAREN, '('], [:RPAREN, ')'], [:RPAREN, ')']]],
+          ['(.:format)', [
+                          [:LPAREN, '('],
+                          [:DOT, '.'],
+                          [:SYMBOL, ':format'],
+                          [:RPAREN, ')'],
+                        ]],
+        ].each do |str, expected|
+          @scanner.scan_setup str
+          assert_tokens expected, @scanner
+        end
+      end
+
+      def assert_tokens tokens, scanner
+        toks = []
+        while tok = scanner.next_token
+          toks << tok
+        end
+        assert_equal tokens, toks
+      end
+    end
+  end
+end

data/vendor/bundle/gems/journey-1.0.4/test/router/test_strexp.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+module Journey
+  class Router
+    class TestStrexp < MiniTest::Unit::TestCase
+      def test_many_names
+        exp = Strexp.new(
+          "/:controller(/:action(/:id(.:format)))",
+          {:controller=>/.+?/},
+          ["/", ".", "?"],
+          true)
+
+        assert_equal ["controller", "action", "id", "format"], exp.names
+      end
+
+      def test_names
+        {
+          "/bar(.:format)"    => %w{ format },
+          ":format"           => %w{ format },
+          ":format-"          => %w{ format },
+          ":format0"          => %w{ format0 },
+          ":format1,:format2" => %w{ format1 format2 },
+        }.each do |string, expected|
+          exp = Strexp.new(string, {}, ["/", ".", "?"])
+          assert_equal expected, exp.names
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/journey-1.0.4/test/router/test_utils.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+module Journey
+  class Router
+    class TestUtils < MiniTest::Unit::TestCase
+      def test_path_escape
+        assert_equal "a/b%20c+d", Utils.escape_path("a/b c+d")
+      end
+
+      def test_fragment_escape
+        assert_equal "a/b%20c+d?e", Utils.escape_fragment("a/b c+d?e")
+      end
+
+      def test_uri_unescape
+        assert_equal "a/b c+d", Utils.unescape_uri("a%2Fb%20c+d")
+      end
+    end
+  end
+end

data/vendor/bundle/gems/journey-1.0.4/test/test_route.rb

@@ -0,0 +1,109 @@
+require 'helper'
+
+module Journey
+  class TestRoute < MiniTest::Unit::TestCase
+    def test_initialize
+      app      = Object.new
+      path     = Path::Pattern.new '/:controller(/:action(/:id(.:format)))'
+      defaults = Object.new
+      route    = Route.new("name", app, path, {}, defaults)
+
+      assert_equal app, route.app
+      assert_equal path, route.path
+      assert_equal defaults, route.defaults
+    end
+
+    def test_route_adds_itself_as_memo
+      app      = Object.new
+      path     = Path::Pattern.new '/:controller(/:action(/:id(.:format)))'
+      defaults = Object.new
+      route    = Route.new("name", app, path, {}, defaults)
+
+      route.ast.grep(Nodes::Terminal).each do |node|
+        assert_equal route, node.memo
+      end
+    end
+
+    def test_ip_address
+      path  = Path::Pattern.new '/messages/:id(.:format)'
+      route = Route.new("name", nil, path, {:ip => '192.168.1.1'},
+                        { :controller => 'foo', :action => 'bar' })
+      assert_equal '192.168.1.1', route.ip
+    end
+
+    def test_default_ip
+      path  = Path::Pattern.new '/messages/:id(.:format)'
+      route = Route.new("name", nil, path, {},
+                        { :controller => 'foo', :action => 'bar' })
+      assert_equal(//, route.ip)
+    end
+
+    def test_format_empty
+      path  = Path::Pattern.new '/messages/:id(.:format)'
+      route = Route.new("name", nil, path, {},
+                        { :controller => 'foo', :action => 'bar' })
+
+      assert_equal '/messages', route.format({})
+    end
+
+    def test_format_with_star
+      path  = Path::Pattern.new '/:controller/*extra'
+      route = Route.new("name", nil, path, {},
+                        { :controller => 'foo', :action => 'bar' })
+      assert_equal '/foo/himom', route.format({
+        :controller => 'foo',
+        :extra      => 'himom',
+      })
+    end
+
+    def test_connects_all_match
+      path  = Path::Pattern.new '/:controller(/:action(/:id(.:format)))'
+      route = Route.new("name", nil, path, {:action => 'bar'}, { :controller => 'foo' })
+
+      assert_equal '/foo/bar/10', route.format({
+        :controller => 'foo',
+        :action     => 'bar',
+        :id         => 10
+      })
+    end
+
+    def test_extras_are_not_included_if_optional
+      path  = Path::Pattern.new '/page/:id(/:action)'
+      route = Route.new("name", nil, path, { }, { :action => 'show' })
+
+      assert_equal '/page/10', route.format({ :id => 10 })
+    end
+
+    def test_extras_are_not_included_if_optional_with_parameter
+      path  = Path::Pattern.new '(/sections/:section)/pages/:id'
+      route = Route.new("name", nil, path, { }, { :action => 'show' })
+
+      assert_equal '/pages/10', route.format({:id => 10})
+    end
+
+    def test_extras_are_not_included_if_optional_parameter_is_nil
+      path  = Path::Pattern.new '(/sections/:section)/pages/:id'
+      route = Route.new("name", nil, path, { }, { :action => 'show' })
+
+      assert_equal '/pages/10', route.format({:id => 10, :section => nil})
+    end
+
+    def test_score
+      path = Path::Pattern.new "/page/:id(/:action)(.:format)"
+      specific = Route.new "name", nil, path, {}, {:controller=>"pages", :action=>"show"}
+
+      path = Path::Pattern.new "/:controller(/:action(/:id))(.:format)"
+      generic = Route.new "name", nil, path, {}
+
+      knowledge = {:id=>20, :controller=>"pages", :action=>"show"}
+
+      routes = [specific, generic]
+
+      refute_equal specific.score(knowledge), generic.score(knowledge)
+
+      found = routes.sort_by { |r| r.score(knowledge) }.last
+
+      assert_equal specific, found
+    end
+  end
+end

data/vendor/bundle/gems/journey-1.0.4/test/test_router.rb

@@ -0,0 +1,544 @@
+# encoding: UTF-8
+require 'helper'
+
+module Journey
+  class TestRouter < MiniTest::Unit::TestCase
+    attr_reader :routes
+
+    def setup
+      @routes    = Routes.new
+      @router    = Router.new(@routes, {})
+      @formatter = Formatter.new(@routes)
+    end
+
+    def test_request_class_reader
+      klass = Object.new
+      router = Router.new(routes, :request_class => klass)
+      assert_equal klass, router.request_class
+    end
+
+    class FakeRequestFeeler < Struct.new(:env, :called)
+      def new env
+        self.env = env
+        self
+      end
+
+      def hello
+        self.called = true
+        'world'
+      end
+
+      def path_info; env['PATH_INFO']; end
+      def request_method; env['REQUEST_METHOD']; end
+      def ip; env['REMOTE_ADDR']; end
+    end
+
+    def test_dashes
+      klass  = FakeRequestFeeler.new nil
+      router = Router.new(routes, {})
+
+      exp = Router::Strexp.new '/foo-bar-baz', {}, ['/.?']
+      path  = Path::Pattern.new exp
+
+      routes.add_route nil, path, {}, {:id => nil}, {}
+
+      env = rails_env 'PATH_INFO' => '/foo-bar-baz'
+      called = false
+      router.recognize(env) do |r, _, params|
+        called = true
+      end
+      assert called
+    end
+
+    def test_unicode
+      klass  = FakeRequestFeeler.new nil
+      router = Router.new(routes, {})
+
+      #match the escaped version of /ほげ
+      exp = Router::Strexp.new '/%E3%81%BB%E3%81%92', {}, ['/.?']
+      path  = Path::Pattern.new exp
+
+      routes.add_route nil, path, {}, {:id => nil}, {}
+
+      env = rails_env 'PATH_INFO' => '/%E3%81%BB%E3%81%92'
+      called = false
+      router.recognize(env) do |r, _, params|
+        called = true
+      end
+      assert called
+    end
+
+    def test_request_class_and_requirements_success
+      klass  = FakeRequestFeeler.new nil
+      router = Router.new(routes, {:request_class => klass })
+
+      requirements = { :hello => /world/ }
+
+      exp = Router::Strexp.new '/foo(/:id)', {}, ['/.?']
+      path  = Path::Pattern.new exp
+
+      routes.add_route nil, path, requirements, {:id => nil}, {}
+
+      env = rails_env 'PATH_INFO' => '/foo/10'
+      router.recognize(env) do |r, _, params|
+        assert_equal({:id => '10'}, params)
+      end
+
+      assert klass.called, 'hello should have been called'
+      assert_equal env.env, klass.env
+    end
+
+    def test_request_class_and_requirements_fail
+      klass  = FakeRequestFeeler.new nil
+      router = Router.new(routes, {:request_class => klass })
+
+      requirements = { :hello => /mom/ }
+
+      exp = Router::Strexp.new '/foo(/:id)', {}, ['/.?']
+      path  = Path::Pattern.new exp
+
+      router.routes.add_route nil, path, requirements, {:id => nil}, {}
+
+      env = rails_env 'PATH_INFO' => '/foo/10'
+      router.recognize(env) do |r, _, params|
+        flunk 'route should not be found'
+      end
+
+      assert klass.called, 'hello should have been called'
+      assert_equal env.env, klass.env
+    end
+
+    class CustomPathRequest < Router::NullReq
+      def path_info
+        env['custom.path_info']
+      end
+    end
+
+    def test_request_class_overrides_path_info
+      router = Router.new(routes, {:request_class => CustomPathRequest })
+
+      exp = Router::Strexp.new '/bar', {}, ['/.?']
+      path = Path::Pattern.new exp
+
+      routes.add_route nil, path, {}, {}, {}
+
+      env = rails_env 'PATH_INFO' => '/foo', 'custom.path_info' => '/bar'
+
+      recognized = false
+      router.recognize(env) do |r, _, params|
+        recognized = true
+      end
+
+      assert recognized, "route should have been recognized"
+    end
+
+    def test_regexp_first_precedence
+      add_routes @router, [
+        Router::Strexp.new("/whois/:domain", {:domain => /\w+\.[\w\.]+/}, ['/', '.', '?']),
+        Router::Strexp.new("/whois/:id(.:format)", {}, ['/', '.', '?'])
+      ]
+
+      env = rails_env 'PATH_INFO' => '/whois/example.com'
+
+      list = []
+      @router.recognize(env) do |r, _, params|
+        list << r
+      end
+      assert_equal 2, list.length
+
+      r = list.first
+
+      assert_equal '/whois/:domain', r.path.spec.to_s
+    end
+
+    def test_required_parts_verified_are_anchored
+      add_routes @router, [
+        Router::Strexp.new("/foo/:id", { :id => /\d/ }, ['/', '.', '?'], false)
+      ]
+
+      assert_raises(Router::RoutingError) do
+        @formatter.generate(:path_info, nil, { :id => '10' }, { })
+      end
+    end
+
+    def test_required_parts_are_verified_when_building
+      add_routes @router, [
+        Router::Strexp.new("/foo/:id", { :id => /\d+/ }, ['/', '.', '?'], false)
+      ]
+
+      path, _ = @formatter.generate(:path_info, nil, { :id => '10' }, { })
+      assert_equal '/foo/10', path
+
+      assert_raises(Router::RoutingError) do
+        @formatter.generate(:path_info, nil, { :id => 'aa' }, { })
+      end
+    end
+
+    def test_only_required_parts_are_verified
+      add_routes @router, [
+        Router::Strexp.new("/foo(/:id)", {:id => /\d/}, ['/', '.', '?'], false)
+      ]
+
+      path, _ = @formatter.generate(:path_info, nil, { :id => '10' }, { })
+      assert_equal '/foo/10', path
+
+      path, _ = @formatter.generate(:path_info, nil, { }, { })
+      assert_equal '/foo', path
+
+      path, _ = @formatter.generate(:path_info, nil, { :id => 'aa' }, { })
+      assert_equal '/foo/aa', path
+    end
+
+    def test_X_Cascade
+      add_routes @router, [ "/messages(.:format)" ]
+      resp = @router.call({ 'REQUEST_METHOD' => 'GET', 'PATH_INFO' => '/lol' })
+      assert_equal ['Not Found'], resp.last
+      assert_equal 'pass', resp[1]['X-Cascade']
+      assert_equal 404, resp.first
+    end
+
+    def test_clear_trailing_slash_from_script_name_on_root_unanchored_routes
+      strexp = Router::Strexp.new("/", {}, ['/', '.', '?'], false)
+      path   = Path::Pattern.new strexp
+      app    = lambda { |env| [200, {}, ['success!']] }
+      @router.routes.add_route(app, path, {}, {}, {})
+
+      env  = rack_env('SCRIPT_NAME' => '', 'PATH_INFO' => '/weblog')
+      resp = @router.call(env)
+      assert_equal ['success!'], resp.last
+      assert_equal '', env['SCRIPT_NAME']
+      assert_equal '/weblog', env['PATH_INFO']
+    end
+
+    def test_defaults_merge_correctly
+      path  = Path::Pattern.new '/foo(/:id)'
+      @router.routes.add_route nil, path, {}, {:id => nil}, {}
+
+      env = rails_env 'PATH_INFO' => '/foo/10'
+      @router.recognize(env) do |r, _, params|
+        assert_equal({:id => '10'}, params)
+      end
+
+      env = rails_env 'PATH_INFO' => '/foo'
+      @router.recognize(env) do |r, _, params|
+        assert_equal({:id => nil}, params)
+      end
+    end
+
+    def test_recognize_with_unbound_regexp
+      add_routes @router, [
+        Router::Strexp.new("/foo", { }, ['/', '.', '?'], false)
+      ]
+
+      env = rails_env 'PATH_INFO' => '/foo/bar'
+
+      @router.recognize(env) { |*_| }
+
+      assert_equal '/foo', env.env['SCRIPT_NAME']
+      assert_equal '/bar', env.env['PATH_INFO']
+    end
+
+    def test_bound_regexp_keeps_path_info
+      add_routes @router, [
+        Router::Strexp.new("/foo", { }, ['/', '.', '?'], true)
+      ]
+
+      env = rails_env 'PATH_INFO' => '/foo'
+
+      before = env.env['SCRIPT_NAME']
+
+      @router.recognize(env) { |*_| }
+
+      assert_equal before, env.env['SCRIPT_NAME']
+      assert_equal '/foo', env.env['PATH_INFO']
+    end
+
+    def test_path_not_found
+      add_routes @router, [
+        "/messages(.:format)",
+        "/messages/new(.:format)",
+        "/messages/:id/edit(.:format)",
+        "/messages/:id(.:format)"
+      ]
+      env = rails_env 'PATH_INFO' => '/messages/unknown/path'
+      yielded = false
+
+      @router.recognize(env) do |*whatever|
+        yielded = true
+      end
+      refute yielded
+    end
+
+    def test_required_part_in_recall
+      add_routes @router, [ "/messages/:a/:b" ]
+
+      path, _ = @formatter.generate(:path_info, nil, { :a => 'a' }, { :b => 'b' })
+      assert_equal "/messages/a/b", path
+    end
+
+    def test_splat_in_recall
+      add_routes @router, [ "/*path" ]
+
+      path, _ = @formatter.generate(:path_info, nil, { }, { :path => 'b' })
+      assert_equal "/b", path
+    end
+
+    def test_recall_should_be_used_when_scoring
+      add_routes @router, [
+        "/messages/:action(/:id(.:format))",
+        "/messages/:id(.:format)"
+      ]
+
+      path, _ = @formatter.generate(:path_info, nil, { :id => 10 }, { :action => 'index' })
+      assert_equal "/messages/index/10", path
+    end
+
+    def test_nil_path_parts_are_ignored
+      path  = Path::Pattern.new "/:controller(/:action(.:format))"
+      @router.routes.add_route nil, path, {}, {}, {}
+
+      params = { :controller => "tasks", :format => nil }
+      extras = { :action => 'lol' }
+
+      path, _ = @formatter.generate(:path_info, nil, params, extras)
+      assert_equal '/tasks', path
+    end
+
+    def test_generate_slash
+      params = [ [:controller, "tasks"],
+                 [:action, "show"] ]
+      str = Router::Strexp.new("/", Hash[params], ['/', '.', '?'], true)
+      path  = Path::Pattern.new str
+
+      @router.routes.add_route nil, path, {}, {}, {}
+
+      path, _ = @formatter.generate(:path_info, nil, Hash[params], {})
+      assert_equal '/', path
+    end
+
+    def test_generate_calls_param_proc
+      path  = Path::Pattern.new '/:controller(/:action)'
+      @router.routes.add_route nil, path, {}, {}, {}
+
+      parameterized = []
+      params = [ [:controller, "tasks"],
+                 [:action, "show"] ]
+
+      @formatter.generate(
+        :path_info,
+        nil,
+        Hash[params],
+        {},
+        lambda { |k,v| parameterized << [k,v]; v })
+
+      assert_equal params.map(&:to_s).sort, parameterized.map(&:to_s).sort
+    end
+
+    def test_generate_id
+      path  = Path::Pattern.new '/:controller(/:action)'
+      @router.routes.add_route nil, path, {}, {}, {}
+
+      path, params = @formatter.generate(
+        :path_info, nil, {:id=>1, :controller=>"tasks", :action=>"show"}, {})
+      assert_equal '/tasks/show', path
+      assert_equal({:id => 1}, params)
+    end
+
+    def test_generate_escapes
+      path  = Path::Pattern.new '/:controller(/:action)'
+      @router.routes.add_route nil, path, {}, {}, {}
+
+      path, _ = @formatter.generate(:path_info,
+        nil, { :controller        => "tasks",
+               :action            => "a/b c+d",
+      }, {})
+      assert_equal '/tasks/a/b%20c+d', path
+    end
+
+    def test_generate_extra_params
+      path  = Path::Pattern.new '/:controller(/:action)'
+      @router.routes.add_route nil, path, {}, {}, {}
+
+      path, params = @formatter.generate(:path_info,
+        nil, { :id                => 1,
+               :controller        => "tasks",
+               :action            => "show",
+               :relative_url_root => nil
+      }, {})
+      assert_equal '/tasks/show', path
+      assert_equal({:id => 1, :relative_url_root => nil}, params)
+    end
+
+    def test_generate_uses_recall_if_needed
+      path  = Path::Pattern.new '/:controller(/:action(/:id))'
+      @router.routes.add_route nil, path, {}, {}, {}
+
+      path, params = @formatter.generate(:path_info,
+        nil,
+        {:controller =>"tasks", :id => 10},
+        {:action     =>"index"})
+      assert_equal '/tasks/index/10', path
+      assert_equal({}, params)
+    end
+
+    def test_generate_with_name
+      path  = Path::Pattern.new '/:controller(/:action)'
+      @router.routes.add_route nil, path, {}, {}, {}
+
+      path, params = @formatter.generate(:path_info,
+        "tasks",
+        {:controller=>"tasks"},
+        {:controller=>"tasks", :action=>"index"})
+      assert_equal '/tasks', path
+      assert_equal({}, params)
+    end
+
+    {
+      '/content'          => { :controller => 'content' },
+      '/content/list'     => { :controller => 'content', :action => 'list' },
+      '/content/show/10'  => { :controller => 'content', :action => 'show', :id => "10" },
+    }.each do |request_path, expected|
+      define_method("test_recognize_#{expected.keys.map(&:to_s).join('_')}") do
+        path  = Path::Pattern.new "/:controller(/:action(/:id))"
+        app   = Object.new
+        route = @router.routes.add_route(app, path, {}, {}, {})
+
+        env = rails_env 'PATH_INFO' => request_path
+        called   = false
+
+        @router.recognize(env) do |r, _, params|
+          assert_equal route, r
+          assert_equal(expected, params)
+          called = true
+        end
+
+        assert called
+      end
+    end
+
+    {
+      :segment => ['/a%2Fb%20c+d/splat', { :segment => 'a/b c+d', :splat => 'splat'   }],
+      :splat   => ['/segment/a/b%20c+d', { :segment => 'segment', :splat => 'a/b c+d' }]
+    }.each do |name, (request_path, expected)|
+      define_method("test_recognize_#{name}") do
+        path  = Path::Pattern.new '/:segment/*splat'
+        app   = Object.new
+        route = @router.routes.add_route(app, path, {}, {}, {})
+
+        env = rails_env 'PATH_INFO' => request_path
+        called   = false
+
+        @router.recognize(env) do |r, _, params|
+          assert_equal route, r
+          assert_equal(expected, params)
+          called = true
+        end
+
+        assert called
+      end
+    end
+
+    def test_namespaced_controller
+      strexp = Router::Strexp.new(
+        "/:controller(/:action(/:id))",
+        { :controller => /.+?/ },
+        ["/", ".", "?"]
+      )
+      path  = Path::Pattern.new strexp
+      app   = Object.new
+      route = @router.routes.add_route(app, path, {}, {}, {})
+
+      env = rails_env 'PATH_INFO' => '/admin/users/show/10'
+      called   = false
+      expected = {
+        :controller => 'admin/users',
+        :action     => 'show',
+        :id         => '10'
+      }
+
+      @router.recognize(env) do |r, _, params|
+        assert_equal route, r
+        assert_equal(expected, params)
+        called = true
+      end
+      assert called
+    end
+
+    def test_recognize_literal
+      path   = Path::Pattern.new "/books(/:action(.:format))"
+      app    = Object.new
+      route  = @router.routes.add_route(app, path, {}, {:controller => 'books'})
+
+      env    = rails_env 'PATH_INFO' => '/books/list.rss'
+      expected = { :controller => 'books', :action => 'list', :format => 'rss' }
+      called = false
+      @router.recognize(env) do |r, _, params|
+        assert_equal route, r
+        assert_equal(expected, params)
+        called = true
+      end
+
+      assert called
+    end
+
+    def test_recognize_cares_about_verbs
+      path   = Path::Pattern.new "/books(/:action(.:format))"
+      app    = Object.new
+      conditions = {
+        :request_method => 'GET'
+      }
+      @router.routes.add_route(app, path, conditions, {})
+
+      conditions = conditions.dup
+      conditions[:request_method] = 'POST'
+
+      post = @router.routes.add_route(app, path, conditions, {})
+
+      env = rails_env 'PATH_INFO' => '/books/list.rss',
+                      "REQUEST_METHOD"    => "POST"
+
+      called = false
+      @router.recognize(env) do |r, _, params|
+        assert_equal post, r
+        called = true
+      end
+
+      assert called
+    end
+
+    private
+
+    def add_routes router, paths
+      paths.each do |path|
+        path  = Path::Pattern.new path
+        router.routes.add_route nil, path, {}, {}, {}
+      end
+    end
+
+    RailsEnv = Struct.new(:env)
+
+    def rails_env env
+      RailsEnv.new rack_env env
+    end
+
+    def rack_env env
+      {
+        "rack.version"      => [1, 1],
+        "rack.input"        => StringIO.new,
+        "rack.errors"       => StringIO.new,
+        "rack.multithread"  => true,
+        "rack.multiprocess" => true,
+        "rack.run_once"     => false,
+        "REQUEST_METHOD"    => "GET",
+        "SERVER_NAME"       => "example.org",
+        "SERVER_PORT"       => "80",
+        "QUERY_STRING"      => "",
+        "PATH_INFO"         => "/content",
+        "rack.url_scheme"   => "http",
+        "HTTPS"             => "off",
+        "SCRIPT_NAME"       => "",
+        "CONTENT_LENGTH"    => "0"
+      }.merge env
+    end
+  end
+end