journey 1.0.0.rc1

data/test/gtg/test_builder.rb

@@ -0,0 +1,77 @@
+require 'helper'
+
+module Journey
+  module GTG
+    class TestBuilder < MiniTest::Unit::TestCase
+      def test_following_states_multi
+        table  = tt ['a|a']
+        assert_equal 1, table.move(0, 'a').length
+      end
+
+      def test_following_states_multi_regexp
+        table  = tt [':a|b']
+        assert_equal 1, table.move(0, 'fooo').length
+        assert_equal 2, table.move(0, 'b').length
+      end
+
+      def test_multi_path
+        table  = tt ['/:a/d', '/b/c']
+
+        [
+          [1, '/'],
+          [2, 'b'],
+          [2, '/'],
+          [1, 'c'],
+        ].inject(0) { |state, (exp, sym)|
+          new = table.move(state, sym)
+          assert_equal exp, new.length
+          new
+        }
+      end
+
+      def test_match_data_ambiguous
+        table = tt %w{
+          /articles(.:format)
+          /articles/new(.:format)
+          /articles/:id/edit(.:format)
+          /articles/:id(.:format)
+        }
+
+        sim     = NFA::Simulator.new table
+
+        match = sim.match '/articles/new'
+        assert_equal 2, match.memos.length
+      end
+
+      ##
+      # Identical Routes may have different restrictions.
+      def test_match_same_paths
+        table = tt %w{
+          /articles/new(.:format)
+          /articles/new(.:format)
+        }
+
+        sim     = NFA::Simulator.new table
+
+        match = sim.match '/articles/new'
+        assert_equal 2, match.memos.length
+      end
+
+      private
+      def ast strings
+        parser = Journey::Parser.new
+        asts   = strings.map { |string|
+          memo = Object.new
+          ast  = parser.parse string
+          ast.each { |n| n.memo = memo }
+          ast
+        }
+        Nodes::Or.new asts
+      end
+
+      def tt strings
+        Builder.new(ast(strings)).transition_table
+      end
+    end
+  end
+end

data/test/gtg/test_transition_table.rb

@@ -0,0 +1,113 @@
+require 'helper'
+require 'json'
+
+module Journey
+  module GTG
+    class TestGeneralizedTable < MiniTest::Unit::TestCase
+      def test_to_json
+        table = tt %w{
+          /articles(.:format)
+          /articles/new(.:format)
+          /articles/:id/edit(.:format)
+          /articles/:id(.:format)
+        }
+
+        json = JSON.load table.to_json
+        assert json['regexp_states']
+        assert json['string_states']
+        assert json['accepting']
+      end
+
+      if system("dot -V 2>/dev/null")
+        def test_to_svg
+          table = tt %w{
+            /articles(.:format)
+            /articles/new(.:format)
+            /articles/:id/edit(.:format)
+            /articles/:id(.:format)
+          }
+          svg = table.to_svg
+          assert svg
+          refute_match(/DOCTYPE/, svg)
+        end
+      end
+
+      def test_simulate_gt
+        sim = simulator_for ['/foo', '/bar']
+        assert_match sim, '/foo'
+      end
+
+      def test_simulate_gt_regexp
+        sim = simulator_for [':foo']
+        assert_match sim, 'foo'
+      end
+
+      def test_simulate_gt_regexp_mix
+        sim = simulator_for ['/get', '/:method/foo']
+        assert_match sim, '/get'
+        assert_match sim, '/get/foo'
+      end
+
+      def test_simulate_optional
+        sim = simulator_for ['/foo(/bar)']
+        assert_match sim, '/foo'
+        assert_match sim, '/foo/bar'
+        refute_match sim, '/foo/'
+      end
+
+      def test_match_data
+        path_asts = asts %w{ /get /:method/foo }
+        paths     = path_asts.dup
+
+        builder = GTG::Builder.new Nodes::Or.new path_asts
+        tt = builder.transition_table
+
+        sim = GTG::Simulator.new tt
+
+        match = sim.match '/get'
+        assert_equal [paths.first], match.memos
+
+        match = sim.match '/get/foo'
+        assert_equal [paths.last], match.memos
+      end
+
+      def test_match_data_ambiguous
+        path_asts = asts %w{
+          /articles(.:format)
+          /articles/new(.:format)
+          /articles/:id/edit(.:format)
+          /articles/:id(.:format)
+        }
+
+        paths = path_asts.dup
+        ast   = Nodes::Or.new path_asts
+
+        builder = GTG::Builder.new ast
+        sim     = GTG::Simulator.new builder.transition_table
+
+        match = sim.match '/articles/new'
+        assert_equal [paths[1], paths[3]], match.memos
+      end
+
+      private
+      def asts paths
+        parser  = Journey::Parser.new
+        paths.map { |x|
+          ast = parser.parse x
+          ast.each { |n| n.memo = ast}
+          ast
+        }
+      end
+
+      def tt paths
+        x = asts paths
+        builder = GTG::Builder.new Nodes::Or.new x
+        builder.transition_table
+      end
+
+      def simulator_for paths
+        GTG::Simulator.new tt(paths)
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'journey'
+require 'stringio'

data/test/nfa/test_simulator.rb

@@ -0,0 +1,96 @@
+require 'helper'
+
+module Journey
+  module NFA
+    class TestSimulator < MiniTest::Unit::TestCase
+      def test_simulate_simple
+        sim = simulator_for ['/foo']
+        assert_match sim, '/foo'
+      end
+
+      def test_simulate_simple_no_match
+        sim = simulator_for ['/foo']
+        refute_match sim, 'foo'
+      end
+
+      def test_simulate_simple_no_match_too_long
+        sim = simulator_for ['/foo']
+        refute_match sim, '/foo/bar'
+      end
+
+      def test_simulate_simple_no_match_wrong_string
+        sim = simulator_for ['/foo']
+        refute_match sim, '/bar'
+      end
+
+      def test_simulate_regex
+        sim = simulator_for ['/:foo/bar']
+        assert_match sim, '/bar/bar'
+        assert_match sim, '/foo/bar'
+      end
+
+      def test_simulate_or
+        sim = simulator_for ['/foo', '/bar']
+        assert_match sim, '/bar'
+        assert_match sim, '/foo'
+        refute_match sim, '/baz'
+      end
+
+      def test_simulate_optional
+        sim = simulator_for ['/foo(/bar)']
+        assert_match sim, '/foo'
+        assert_match sim, '/foo/bar'
+        refute_match sim, '/foo/'
+      end
+
+      def test_matchdata_has_memos
+        paths   = %w{ /foo /bar }
+        parser  = Journey::Parser.new
+        asts    = paths.map { |x|
+          ast = parser.parse x
+          ast.each { |n| n.memo = ast}
+          ast
+        }
+
+        expected = asts.first
+
+        builder = Builder.new Nodes::Or.new asts
+
+        sim = Simulator.new builder.transition_table
+
+        md = sim.match '/foo'
+        assert_equal [expected], md.memos
+      end
+
+      def test_matchdata_memos_on_merge
+        parser = Journey::Parser.new
+        routes = [
+          '/articles(.:format)',
+          '/articles/new(.:format)',
+          '/articles/:id/edit(.:format)',
+          '/articles/:id(.:format)',
+        ].map { |path|
+          ast = parser.parse path
+          ast.each { |n| n.memo = ast }
+          ast
+        }
+
+        asts = routes.dup
+
+        ast = Nodes::Or.new routes
+
+        nfa   = Journey::NFA::Builder.new ast
+        sim = Simulator.new nfa.transition_table
+        md = sim.match '/articles'
+        assert_equal [asts.first], md.memos
+      end
+
+      def simulator_for paths
+        parser  = Journey::Parser.new
+        asts    = paths.map { |x| parser.parse x }
+        builder = Builder.new Nodes::Or.new asts
+        Simulator.new builder.transition_table
+      end
+    end
+  end
+end

data/test/nfa/test_transition_table.rb

@@ -0,0 +1,70 @@
+require 'helper'
+
+module Journey
+  module NFA
+    class TestTransitionTable < MiniTest::Unit::TestCase
+      def setup
+        @parser = Journey::Parser.new
+      end
+
+      def test_eclosure
+        table = tt '/'
+        assert_equal [0], table.eclosure(0)
+
+        table = tt ':a|:b'
+        assert_equal 3, table.eclosure(0).length
+
+        table = tt '(:a|:b)'
+        assert_equal 5, table.eclosure(0).length
+        assert_equal 5, table.eclosure([0]).length
+      end
+
+      def test_following_states_one
+        table = tt '/'
+
+        assert_equal [1], table.following_states(0, '/')
+        assert_equal [1], table.following_states([0], '/')
+      end
+
+      def test_following_states_group
+        table  = tt 'a|b'
+        states = table.eclosure 0
+
+        assert_equal 1, table.following_states(states, 'a').length
+        assert_equal 1, table.following_states(states, 'b').length
+      end
+
+      def test_following_states_multi
+        table  = tt 'a|a'
+        states = table.eclosure 0
+
+        assert_equal 2, table.following_states(states, 'a').length
+        assert_equal 0, table.following_states(states, 'b').length
+      end
+
+      def test_following_states_regexp
+        table  = tt 'a|:a'
+        states = table.eclosure 0
+
+        assert_equal 1, table.following_states(states, 'a').length
+        assert_equal 1, table.following_states(states, /[^\.\/\?]+/).length
+        assert_equal 0, table.following_states(states, 'b').length
+      end
+
+      def test_alphabet
+        table  = tt 'a|:a'
+        assert_equal ['a', /[^\.\/\?]+/], table.alphabet
+
+        table  = tt 'a|a'
+        assert_equal ['a'], table.alphabet
+      end
+
+      private
+      def tt string
+        ast     = @parser.parse string
+        builder = Builder.new ast
+        builder.transition_table
+      end
+    end
+  end
+end

data/test/nodes/test_symbol.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+module Journey
+  module Nodes
+    class TestSymbol < MiniTest::Unit::TestCase
+      def test_default_regexp?
+        sym = Symbol.new nil
+        assert sym.default_regexp?
+
+        sym.regexp = nil
+        refute sym.default_regexp?
+      end
+    end
+  end
+end

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