andyjeffries-journey 1.0.0

data/test/path/test_pattern.rb

@@ -0,0 +1,260 @@
+require 'helper'
+
+module Journey
+  module Path
+    class TestPattern < MiniTest::Unit::TestCase
+      x = /.+/
+      {
+        '/:controller(/:action)'       => %r{\A/(#{x}?)(?:/([^/.?]+))?\Z},
+        '/:controller/foo'             => %r{\A/(#{x}?)/foo\Z},
+        '/:controller/:action'         => %r{\A/(#{x}?)/([^/.?]+)\Z},
+        '/:controller'                 => %r{\A/(#{x}?)\Z},
+        '/:controller(/:action(/:id))' => %r{\A/(#{x}?)(?:/([^/.?]+)(?:/([^/.?]+))?)?\Z},
+        '/:controller/:action.xml'     => %r{\A/(#{x}?)/([^/.?]+)\.xml\Z},
+        '/:controller.:format'         => %r{\A/(#{x}?)\.([^/.?]+)\Z},
+        '/:controller(.:format)'       => %r{\A/(#{x}?)(?:\.([^/.?]+))?\Z},
+        '/:controller/*foo'            => %r{\A/(#{x}?)/(.+)\Z},
+        '/:controller/*foo/bar'        => %r{\A/(#{x}?)/(.+)/bar\Z},
+      }.each do |path, expected|
+        define_method(:"test_to_regexp_#{path}") do
+          strexp = Router::Strexp.new(
+            path,
+            { :controller => /.+/ },
+            ["/", ".", "?"]
+          )
+          path = Pattern.new strexp
+          assert_equal(expected, path.send(:to_regexp))
+        end
+      end
+
+      {
+        '/:controller(/:action)'       => %r{\A/(#{x}?)(?:/([^/.?]+))?},
+        '/:controller/foo'             => %r{\A/(#{x}?)/foo},
+        '/:controller/:action'         => %r{\A/(#{x}?)/([^/.?]+)},
+        '/:controller'                 => %r{\A/(#{x}?)},
+        '/:controller(/:action(/:id))' => %r{\A/(#{x}?)(?:/([^/.?]+)(?:/([^/.?]+))?)?},
+        '/:controller/:action.xml'     => %r{\A/(#{x}?)/([^/.?]+)\.xml},
+        '/:controller.:format'         => %r{\A/(#{x}?)\.([^/.?]+)},
+        '/:controller(.:format)'       => %r{\A/(#{x}?)(?:\.([^/.?]+))?},
+        '/:controller/*foo'            => %r{\A/(#{x}?)/(.+)},
+        '/:controller/*foo/bar'        => %r{\A/(#{x}?)/(.+)/bar},
+      }.each do |path, expected|
+        define_method(:"test_to_non_anchored_regexp_#{path}") do
+          strexp = Router::Strexp.new(
+            path,
+            { :controller => /.+/ },
+            ["/", ".", "?"],
+            false
+          )
+          path = Pattern.new strexp
+          assert_equal(expected, path.send(:to_regexp))
+        end
+      end
+
+      {
+        '/:controller(/:action)'       => %w{ controller action },
+        '/:controller/foo'             => %w{ controller },
+        '/:controller/:action'         => %w{ controller action },
+        '/:controller'                 => %w{ controller },
+        '/:controller(/:action(/:id))' => %w{ controller action id },
+        '/:controller/:action.xml'     => %w{ controller action },
+        '/:controller.:format'         => %w{ controller format },
+        '/:controller(.:format)'       => %w{ controller format },
+        '/:controller/*foo'            => %w{ controller foo },
+        '/:controller/*foo/bar'        => %w{ controller foo },
+      }.each do |path, expected|
+        define_method(:"test_names_#{path}") do
+          strexp = Router::Strexp.new(
+            path,
+            { :controller => /.+/ },
+            ["/", ".", "?"]
+          )
+          path = Pattern.new strexp
+          assert_equal(expected, path.names)
+        end
+      end
+
+      def test_to_regexp_with_extended_group
+        strexp = Router::Strexp.new(
+          '/page/:name',
+          { :name => /
+            #ROFL
+            (tender|love
+            #MAO
+            )/x },
+          ["/", ".", "?"]
+        )
+        path = Pattern.new strexp
+        assert_match('/page/tender', path)
+        assert_match('/page/love', path)
+        refute_match('/page/loving', path)
+      end
+
+      def test_optional_names
+        [
+          ['/:foo(/:bar(/:baz))', %w{ bar baz }],
+          ['/:foo(/:bar)', %w{ bar }],
+          ['/:foo(/:bar)/:lol(/:baz)', %w{ bar baz }],
+        ].each do |pattern, list|
+          path = Pattern.new pattern
+          assert_equal list.sort, path.optional_names.sort
+        end
+      end
+
+      def test_to_regexp_with_group
+        strexp = Router::Strexp.new(
+          '/page/:name',
+          { :name => /(tender|love)/ },
+          ["/", ".", "?"]
+        )
+        path = Pattern.new strexp
+        assert_match('/page/tender', path)
+        assert_match('/page/love', path)
+        refute_match('/page/loving', path)
+      end
+
+      def test_ast_sets_regular_expressions
+        requirements = { :name => /(tender|love)/, :value => /./ }
+        strexp = Router::Strexp.new(
+          '/page/:name/:value',
+          requirements,
+          ["/", ".", "?"]
+        )
+
+        assert_equal requirements, strexp.requirements
+
+        path = Pattern.new strexp
+        nodes = path.ast.grep(Nodes::Symbol)
+        assert_equal 2, nodes.length
+        nodes.each do |node|
+          assert_equal requirements[node.to_sym], node.regexp
+        end
+      end
+
+      def test_match_data_with_group
+        strexp = Router::Strexp.new(
+          '/page/:name',
+          { :name => /(tender|love)/ },
+          ["/", ".", "?"]
+        )
+        path = Pattern.new strexp
+        match = path.match '/page/tender'
+        assert_equal 'tender', match[1]
+        assert_equal 2, match.length
+      end
+
+      def test_match_data_with_multi_group
+        strexp = Router::Strexp.new(
+          '/page/:name/:id',
+          { :name => /t(((ender|love)))()/ },
+          ["/", ".", "?"]
+        )
+        path = Pattern.new strexp
+        match = path.match '/page/tender/10'
+        assert_equal 'tender', match[1]
+        assert_equal '10', match[2]
+        assert_equal 3, match.length
+        assert_equal %w{ tender 10 }, match.captures
+      end
+
+      def test_insensitive_regexp_with_group
+        strexp = Router::Strexp.new(
+          '/page/:name/aaron',
+          { :name => /(tender|love)/i },
+          ["/", ".", "?"]
+        )
+        path = Pattern.new strexp
+        assert_match('/page/TENDER/aaron', path)
+        assert_match('/page/loVE/aaron', path)
+        refute_match('/page/loVE/AAron', path)
+      end
+
+      def test_to_regexp_with_strexp
+        strexp = Router::Strexp.new('/:controller', { }, ["/", ".", "?"])
+        path = Pattern.new strexp
+        x = %r{\A/([^/.?]+)\Z}
+
+        assert_equal(x.source, path.source)
+      end
+
+      def test_to_regexp_defaults
+        path = Pattern.new '/:controller(/:action(/:id))'
+        expected = %r{\A/([^/.?]+)(?:/([^/.?]+)(?:/([^/.?]+))?)?\Z}
+        assert_equal expected, path.send(:to_regexp)
+      end
+
+      def test_failed_match
+        path = Pattern.new '/:controller(/:action(/:id(.:format)))'
+        uri = 'content'
+
+        refute path =~ uri
+      end
+
+      def test_match_controller
+        path = Pattern.new '/:controller(/:action(/:id(.:format)))'
+        uri = '/content'
+
+        match = path =~ uri
+        assert_equal %w{ controller action id format }, match.names
+        assert_equal 'content', match[1]
+        assert_nil match[2]
+        assert_nil match[3]
+        assert_nil match[4]
+      end
+
+      def test_match_controller_action
+        path = Pattern.new '/:controller(/:action(/:id(.:format)))'
+        uri = '/content/list'
+
+        match = path =~ uri
+        assert_equal %w{ controller action id format }, match.names
+        assert_equal 'content', match[1]
+        assert_equal 'list', match[2]
+        assert_nil match[3]
+        assert_nil match[4]
+      end
+
+      def test_match_controller_action_id
+        path = Pattern.new '/:controller(/:action(/:id(.:format)))'
+        uri = '/content/list/10'
+
+        match = path =~ uri
+        assert_equal %w{ controller action id format }, match.names
+        assert_equal 'content', match[1]
+        assert_equal 'list', match[2]
+        assert_equal '10', match[3]
+        assert_nil match[4]
+      end
+
+      def test_match_literal
+        path = Path::Pattern.new "/books(/:action(.:format))"
+
+        uri = '/books'
+        match = path =~ uri
+        assert_equal %w{ action format }, match.names
+        assert_nil match[1]
+        assert_nil match[2]
+      end
+
+      def test_match_literal_with_action
+        path = Path::Pattern.new "/books(/:action(.:format))"
+
+        uri = '/books/list'
+        match = path =~ uri
+        assert_equal %w{ action format }, match.names
+        assert_equal 'list', match[1]
+        assert_nil match[2]
+      end
+
+      def test_match_literal_with_action_and_format
+        path = Path::Pattern.new "/books(/:action(.:format))"
+
+        uri = '/books/list.rss'
+        match = path =~ uri
+        assert_equal %w{ action format }, match.names
+        assert_equal 'list', match[1]
+        assert_equal 'rss', match[2]
+      end
+    end
+  end
+end

data/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/test/route/definition/test_scanner.rb

@@ -0,0 +1,52 @@
+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, '/'], [: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/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/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/test/test_route.rb

@@ -0,0 +1,95 @@
+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_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