citrus 2.2.2 → 2.3.0

data/test/calc_test.rb

@@ -1,11 +1,11 @@
 require File.expand_path('../helper', __FILE__)
 
-if defined?(Calc)
-  Object.__send__(:remove_const, :Calc)
-end
-
 require File.expand_path('../../examples/calc', __FILE__)
 
 class CalcTest < Test::Unit::TestCase
   include CalcTestMethods
+
+  def do_test(expr)
+    super(expr, Calc)
+  end
 end

data/test/choice_test.rb

@@ -7,8 +7,8 @@ class ChoiceTest < Test::Unit::TestCase
   end
 
   def test_exec
-    a = Rule.new('a')
-    b = Rule.new('b')
+    a = Rule.for('a')
+    b = Rule.for('b')
     rule = Choice.new([ a, b ])
 
     events = rule.exec(Input.new(''))
@@ -16,11 +16,11 @@ class ChoiceTest < Test::Unit::TestCase
 
     events = rule.exec(Input.new('a'))
     assert(events)
-    assert_equal([rule.id, a.id, CLOSE, 1, CLOSE, 1], events)
+    assert_equal([rule, a, CLOSE, 1, CLOSE, 1], events)
 
     events = rule.exec(Input.new('b'))
     assert(events)
-    assert_equal([rule.id, b.id, CLOSE, 1, CLOSE, 1], events)
+    assert_equal([rule, b, CLOSE, 1, CLOSE, 1], events)
   end
 
   def test_to_s
@@ -28,10 +28,16 @@ class ChoiceTest < Test::Unit::TestCase
     assert_equal('"a" | "b"', rule.to_s)
   end
 
-  def test_to_s_embed
+  def test_to_embedded_s
     rule1 = Choice.new(%w<a b>)
     rule2 = Choice.new(%w<c d>)
     rule = Choice.new([rule1, rule2])
     assert_equal('("a" | "b") | ("c" | "d")', rule.to_s)
   end
+
+  def test_to_s_with_label
+    rule = Choice.new(%w<a b>)
+    rule.label = 'a_label'
+    assert_equal('a_label:("a" | "b")', rule.to_s)
+  end
 end

data/test/extension_test.rb

@@ -7,13 +7,11 @@ class ExtensionTest < Test::Unit::TestCase
     end
   end
 
-  NumericProc = Proc.new {
+  module NumericModule
     def add_one
       to_i + 1
     end
-  }
-
-  NumericModule = Module.new(&NumericProc)
+  end
 
   NumericProcBare = Proc.new {
     to_i + 1
@@ -27,14 +25,6 @@ class ExtensionTest < Test::Unit::TestCase
     assert_equal(:test, match.a_test)
   end
 
-  def test_numeric_proc
-    rule = StringTerminal.new('1')
-    rule.extension = NumericProc
-    match = rule.parse('1')
-    assert(match)
-    assert_equal(2, match.add_one)
-  end
-
   def test_numeric_module
     rule = StringTerminal.new('1')
     rule.extension = NumericModule

data/test/file_test.rb

@@ -5,14 +5,14 @@ class CitrusFileTest < Test::Unit::TestCase
   ## File tests
 
   def run_file_test(file, root)
-    match = File.parse(F.read(file), :root => root)
+    match = File.parse(::File.read(file), :root => root)
     assert(match)
   end
 
   %w<rule grammar>.each do |type|
-    Dir[F.dirname(__FILE__) + "/_files/#{type}*.citrus"].each do |path|
+    Dir[::File.dirname(__FILE__) + "/_files/#{type}*.citrus"].each do |path|
       module_eval(<<-CODE.gsub(/^        /, ''), __FILE__, __LINE__ + 1)
-        def test_#{F.basename(path, '.citrus')}
+        def test_#{::File.basename(path, '.citrus')}
           run_file_test("#{path}", :#{type})
         end
       CODE
@@ -24,173 +24,171 @@ class CitrusFileTest < Test::Unit::TestCase
   def test_rule_body_alias
     match = File.parse('rule_name', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Alias, match.value)
   end
 
-  def test_rule_body_terminal
+  def test_rule_body_dot
     match = File.parse('.', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Terminal, match.value)
+  end
 
+  def test_rule_body_character_range
     match = File.parse('[a-z]', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Terminal, match.value)
+  end
 
+  def test_rule_body_terminal
     match = File.parse('/./', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
-    assert_instance_of(Terminal, match.value)
-
-    match = File.parse("[0-9] {\n  def value\n    text.to_i\n  end\n}\n", :root => :rule_body)
-    assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Terminal, match.value)
   end
 
-  def test_rule_body_string_terminal
+  def test_rule_body_string_terminal_empty
     match = File.parse('""', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(StringTerminal, match.value)
+  end
 
+  def test_rule_body_string_terminal
     match = File.parse('"a"', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(StringTerminal, match.value)
+  end
 
+  def test_rule_body_string_terminal_empty_block
     match = File.parse('"" {}', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(StringTerminal, match.value)
   end
 
-  def test_rule_body_repeat
+  def test_rule_body_repeat_string_terminal
     match = File.parse('"a"*', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
-    assert_equal(0, match.value.min)
-    assert_equal(Infinity, match.value.max)
+  end
 
+  def test_rule_body_repeat_empty_string_terminal_block
     match = File.parse('""* {}', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
+  end
 
+  def test_rule_body_repeat_sequence
     match = File.parse('("a" "b")*', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
+  end
 
+  def test_rule_body_repeat_choice
     match = File.parse('("a" | "b")*', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
+  end
 
+  def test_rule_body_repeat_sequence_block
     match = File.parse('("a" "b")* {}', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
+  end
 
+  def test_rule_body_repeat_choice_block
     match = File.parse('("a" | "b")* {}', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
+  end
 
+  def test_rule_body_repeat_sequence_extension
     match = File.parse('("a" "b")* <Module>', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
+  end
 
+  def test_rule_body_repeat_sequence_extension_spaced
     match = File.parse('( "a" "b" )* <Module>', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
+  end
 
+  def test_rule_body_repeat_choice_extension
     match = File.parse('("a" | "b")* <Module>', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
-    assert_instance_of(Repeat, match.value)
-
-    match = File.parse("[0-9]+ {\n  def value\n    text.to_i\n  end\n}\n", :root => :rule_body)
-    assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
   end
 
-  def test_rule_body_choice
-    match = File.parse('"a" | "b"', :root => :rule_body)
+  def test_rule_body_choice_terminal
+    match = File.parse('/./ | /./', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Choice, match.value)
+  end
 
-    match = File.parse('/./ | /./', :root => :rule_body)
+  def test_rule_body_choice_string_terminal
+    match = File.parse('"a" | "b"', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Choice, match.value)
-    assert_equal(1, match.find(:bar).length)
-    assert_equal(2, match.find(:regular_expression).length)
-    assert_equal(0, match.find(:dot).length)
+  end
 
+  def test_rule_body_choice_mixed
     match = File.parse('("a" | /./)', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Choice, match.value)
+  end
 
+  def test_rule_body_choice_extended
     match = File.parse('("a" | "b") <Module>', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Choice, match.value)
   end
 
-  def test_rule_body_sequence
-    match = File.parse('"a" "b"', :root => :rule_body)
+  def test_rule_body_sequence_terminal
+    match = File.parse('/./ /./', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Sequence, match.value)
+  end
 
-    match = File.parse('/./ /./', :root => :rule_body)
+  def test_rule_body_sequence_string_terminal
+    match = File.parse('"a" "b"', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Sequence, match.value)
-    assert_equal(2, match.find(:regular_expression).length)
+  end
 
+  def test_rule_body_sequence_extension
     match = File.parse('( "a" "b" ) <Module>', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Sequence, match.value)
+  end
 
+  def test_rule_body_sequence_mixed
     match = File.parse('"a" ("b" | /./)* <Module>', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Sequence, match.value)
+  end
 
+  def test_rule_body_sequence_block
     match = File.parse('"a" ("b" | /./)* {}', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Sequence, match.value)
   end
 
-  def test_precedence
+  def test_precedence_sequence_before_choice
     # Sequence should bind more tightly than Choice.
     match = File.parse('"a" "b" | "c"', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Choice, match.value)
+  end
 
+  def test_precedence_parentheses
     # Parentheses should change binding precedence.
     match = File.parse('"a" ("b" | "c")', :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Sequence, match.value)
+  end
 
+  def test_precedence_repeat_before_predicate
     # Repeat should bind more tightly than AndPredicate.
     match = File.parse("&'a'+", :root => :rule_body)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(AndPredicate, match.value)
   end
 
@@ -202,31 +200,39 @@ class CitrusFileTest < Test::Unit::TestCase
   def test_choice
     match = File.parse('"a" | "b"', :root => :choice)
     assert(match)
-    assert_equal(2, match.rules.length)
     assert_instance_of(Choice, match.value)
   end
 
   def test_choice_embedded_sequence
     match = File.parse('"a" | ("b" "c")', :root => :choice)
     assert(match)
-    assert_equal(2, match.rules.length)
     assert_instance_of(Choice, match.value)
   end
 
   def test_sequence
     match = File.parse('"" ""', :root => :sequence)
     assert(match)
-    assert_equal(2, match.rules.length)
     assert_instance_of(Sequence, match.value)
   end
 
   def test_sequence_embedded_choice
     match = File.parse('"a" ("b" | "c")', :root => :sequence)
     assert(match)
-    assert_equal(2, match.rules.length)
     assert_instance_of(Sequence, match.value)
   end
 
+  def test_label_expression
+    match = File.parse('label:""', :root => :label_expression)
+    assert(match)
+    assert_instance_of(StringTerminal, match.value)
+  end
+
+  def test_label_expression_space
+    match = File.parse('label :"" ', :root => :label_expression)
+    assert(match)
+    assert_instance_of(StringTerminal, match.value)
+  end
+
   def test_expression_tag
     match = File.parse('"" <Module>', :root => :expression)
     assert(match)
@@ -251,84 +257,66 @@ class CitrusFileTest < Test::Unit::TestCase
   def test_prefix_and
     match = File.parse('&""', :root => :prefix)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(AndPredicate, match.value)
   end
 
   def test_prefix_not
     match = File.parse('!""', :root => :prefix)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(NotPredicate, match.value)
   end
 
-  def test_prefix_label
-    match = File.parse('label:""', :root => :prefix)
+  def test_prefix_but
+    match = File.parse('~""', :root => :prefix)
     assert(match)
-    assert_kind_of(Rule, match.value)
-    assert_instance_of(Label, match.value)
-  end
-
-  def test_prefix_label_space
-    match = File.parse('label :"" ', :root => :prefix)
-    assert(match)
-    assert_kind_of(Rule, match.value)
-    assert_instance_of(Label, match.value)
+    assert_instance_of(ButPredicate, match.value)
   end
 
   def test_suffix_plus
     match = File.parse('""+', :root => :suffix)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
   end
 
   def test_suffix_question
-    match = File.parse('""? ', :root => :suffix)
+    match = File.parse('""?', :root => :suffix)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
   end
 
   def test_suffix_star
     match = File.parse('""*', :root => :suffix)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
   end
 
   def test_suffix_n_star
     match = File.parse('""1*', :root => :suffix)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
   end
 
   def test_suffix_star_n
     match = File.parse('""*2', :root => :suffix)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
   end
 
   def test_suffix_n_star_n
     match = File.parse('""1*2', :root => :suffix)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
   end
 
   def test_primary_alias
     match = File.parse('rule_name', :root => :primary)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Alias, match.value)
   end
 
   def test_primary_string_terminal
     match = File.parse('"a"', :root => :primary)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(StringTerminal, match.value)
   end
 
@@ -393,42 +381,36 @@ class CitrusFileTest < Test::Unit::TestCase
   def test_terminal_character_class
     match = File.parse('[a-z]', :root => :terminal)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Terminal, match.value)
   end
 
   def test_terminal_dot
     match = File.parse('.', :root => :terminal)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Terminal, match.value)
   end
 
   def test_terminal_regular_expression
     match = File.parse('/./', :root => :terminal)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(Terminal, match.value)
   end
 
   def test_string_terminal_single_quoted
     match = File.parse("'a'", :root => :string_terminal)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(StringTerminal, match.value)
   end
 
   def test_string_terminal_double_quoted
     match = File.parse('"a"', :root => :string_terminal)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(StringTerminal, match.value)
   end
 
   def test_string_terminal_case_insensitive
     match = File.parse('`a`', :root => :string_terminal)
     assert(match)
-    assert_kind_of(Rule, match.value)
     assert_instance_of(StringTerminal, match.value)
   end
 
@@ -498,122 +480,96 @@ class CitrusFileTest < Test::Unit::TestCase
     assert_equal('&', match.value)
   end
 
-  def test_character_class
-    match = File.parse('[_]', :root => :character_class)
-    assert(match)
-    assert_equal(/\A[_]/, match.value)
-  end
-
-  def test_character_class_a_z
-    match = File.parse('[a-z]', :root => :character_class)
-    assert(match)
-    assert_equal(/\A[a-z]/, match.value)
-  end
-
-  def test_character_class_a_z_0_9
-    match = File.parse('[a-z0-9]', :root => :character_class)
-    assert(match)
-    assert_equal(/\A[a-z0-9]/, match.value)
-  end
-
-  def test_character_class_nested_square_brackets
-    match = File.parse('[\[-\]]', :root => :character_class)
-    assert(match)
-    assert_equal(/\A[\[-\]]/, match.value)
-  end
-
-  def test_character_class_hex_range
-    match = File.parse('[\\x26-\\x29]', :root => :character_class)
-    assert(match)
-    assert_equal(/\A[\x26-\x29]/, match.value)
-  end
-
-  def test_dot
-    match = File.parse('.', :root => :dot)
-    assert(match)
-    assert_equal(DOT, match.value)
-  end
-
   def test_regular_expression
     match = File.parse('/./', :root => :regular_expression)
     assert(match)
-    assert_equal(/./, match.value)
+    rule = match.value
+    assert_instance_of(Terminal, rule)
+    assert_equal(/./, rule.regexp)
   end
 
   def test_regular_expression_escaped_forward_slash
     match = File.parse('/\\//', :root => :regular_expression)
     assert(match)
-    assert_equal(/\//, match.value)
+    rule = match.value
+    assert_instance_of(Terminal, rule)
+    assert_equal(/\//, rule.regexp)
   end
 
   def test_regular_expression_escaped_backslash
     match = File.parse('/\\\\/', :root => :regular_expression)
     assert(match)
-    assert_equal(/\\/, match.value)
+    rule = match.value
+    assert_instance_of(Terminal, rule)
+    assert_equal(/\\/, rule.regexp)
   end
 
   def test_regular_expression_hex
     match = File.parse('/\\x26/', :root => :regular_expression)
     assert(match)
-    assert_equal(/\x26/, match.value)
+    rule = match.value
+    assert_instance_of(Terminal, rule)
+    assert_equal(/\x26/, rule.regexp)
   end
 
   def test_regular_expression_with_flag
     match = File.parse('/a/i', :root => :regular_expression)
     assert(match)
-    assert_equal(/a/i, match.value)
+    rule = match.value
+    assert_instance_of(Terminal, rule)
+    assert_equal(/a/i, rule.regexp)
   end
 
-  def test_predicate_and
-    match = File.parse('&', :root => :predicate)
-    assert(match)
-    assert_kind_of(Rule, match.value(''))
-  end
-
-  def test_predicate_not
-    match = File.parse('!', :root => :predicate)
+  def test_character_class
+    match = File.parse('[_]', :root => :character_class)
     assert(match)
-    assert_kind_of(Rule, match.value(''))
+    rule = match.value
+    assert_instance_of(Terminal, rule)
+    assert_equal(/[_]/n, rule.regexp)
   end
 
-  def test_and
-    match = File.parse('&', :root => :and)
+  def test_character_class_a_z
+    match = File.parse('[a-z]', :root => :character_class)
     assert(match)
-    assert_instance_of(AndPredicate, match.value(''))
+    rule = match.value
+    assert_instance_of(Terminal, rule)
+    assert_equal(/[a-z]/n, rule.regexp)
   end
 
-  def test_and_space
-    match = File.parse('& ', :root => :and)
+  def test_character_class_nested_square_brackets
+    match = File.parse('[\[-\]]', :root => :character_class)
     assert(match)
-    assert_instance_of(AndPredicate, match.value(''))
+    rule = match.value
+    assert_instance_of(Terminal, rule)
+    assert_equal(/[\[-\]]/n, rule.regexp)
   end
 
-  def test_not
-    match = File.parse('!', :root => :not)
+  def test_character_class_hex_range
+    match = File.parse('[\\x26-\\x29]', :root => :character_class)
     assert(match)
-    assert_instance_of(NotPredicate, match.value(''))
+    rule = match.value
+    assert_instance_of(Terminal, rule)
+    assert_equal(/[\x26-\x29]/, rule.regexp)
   end
 
-  def test_not_space
-    match = File.parse('! ', :root => :not)
+  def test_dot
+    match = File.parse('.', :root => :dot)
     assert(match)
-    assert_instance_of(NotPredicate, match.value(''))
+    rule = match.value
+    assert_instance_of(Terminal, rule)
+    assert_equal(DOT, rule.regexp)
   end
 
   def test_label
     match = File.parse('label:', :root => :label)
     assert(match)
-    v = match.value('')
-    assert_instance_of(Label, v)
-    assert_equal(:label, v.label)
+    assert_equal(:label, match.value)
   end
 
   def test_label_spaced
     match = File.parse('a_label : ', :root => :label)
     assert(match)
-    v = match.value('')
-    assert_instance_of(Label, v)
-    assert_equal(:a_label, v.label)
+    assert_equal(:a_label, match.value)
   end
 
   def test_tag
@@ -672,9 +628,21 @@ class CitrusFileTest < Test::Unit::TestCase
   end
 
   def test_block_def
+    match = File.parse("{def value; 'a' end}", :root => :block)
+    assert(match)
+    assert(match.value)
+    assert_instance_of(Module, match.value)
+    method_names = match.value.instance_methods.map {|m| m.to_sym }
+    assert_equal([:value], method_names)
+  end
+
+  def test_block_def_multiline
     match = File.parse("{\n  def value\n    'a'\n  end\n} ", :root => :block)
     assert(match)
     assert(match.value)
+    assert_instance_of(Module, match.value)
+    method_names = match.value.instance_methods.map {|m| m.to_sym }
+    assert_equal([:value], method_names)
   end
 
   def test_block_with_interpolation
@@ -683,6 +651,60 @@ class CitrusFileTest < Test::Unit::TestCase
     assert(match.value)
   end
 
+  def test_predicate_and
+    match = File.parse('&', :root => :predicate)
+    assert(match)
+    assert_instance_of(AndPredicate, match.value(''))
+  end
+
+  def test_predicate_not
+    match = File.parse('!', :root => :predicate)
+    assert(match)
+    assert_instance_of(NotPredicate, match.value(''))
+  end
+
+  def test_predicate_but
+    match = File.parse('~', :root => :predicate)
+    assert(match)
+    assert_instance_of(ButPredicate, match.value(''))
+  end
+
+  def test_and
+    match = File.parse('&', :root => :and)
+    assert(match)
+    assert_instance_of(AndPredicate, match.value(''))
+  end
+
+  def test_and_space
+    match = File.parse('& ', :root => :and)
+    assert(match)
+    assert_instance_of(AndPredicate, match.value(''))
+  end
+
+  def test_not
+    match = File.parse('!', :root => :not)
+    assert(match)
+    assert_instance_of(NotPredicate, match.value(''))
+  end
+
+  def test_not_space
+    match = File.parse('! ', :root => :not)
+    assert(match)
+    assert_instance_of(NotPredicate, match.value(''))
+  end
+
+  def test_but
+    match = File.parse('~', :root => :but)
+    assert(match)
+    assert_instance_of(ButPredicate, match.value(''))
+  end
+
+  def test_but_space
+    match = File.parse('~ ', :root => :but)
+    assert(match)
+    assert_instance_of(ButPredicate, match.value(''))
+  end
+
   def test_repeat_question
     match = File.parse('?', :root => :repeat)
     assert(match)
@@ -722,64 +744,82 @@ class CitrusFileTest < Test::Unit::TestCase
   def test_question
     match = File.parse('?', :root => :question)
     assert(match)
-    assert_equal(0, match.min)
-    assert_equal(1, match.max)
+    rule = match.value('')
+    assert_instance_of(Repeat, rule)
+    assert_equal(0, rule.min)
+    assert_equal(1, rule.max)
   end
 
   def test_question_space
     match = File.parse('? ', :root => :question)
     assert(match)
-    assert_equal(0, match.min)
-    assert_equal(1, match.max)
+    rule = match.value('')
+    assert_instance_of(Repeat, rule)
+    assert_equal(0, rule.min)
+    assert_equal(1, rule.max)
   end
 
   def test_plus
     match = File.parse('+', :root => :plus)
     assert(match)
-    assert_equal(1, match.min)
-    assert_equal(Infinity, match.max)
+    rule = match.value('')
+    assert_instance_of(Repeat, rule)
+    assert_equal(1, rule.min)
+    assert_equal(Infinity, rule.max)
   end
 
   def test_plus_space
     match = File.parse('+ ', :root => :plus)
     assert(match)
-    assert_equal(1, match.min)
-    assert_equal(Infinity, match.max)
+    rule = match.value('')
+    assert_instance_of(Repeat, rule)
+    assert_equal(1, rule.min)
+    assert_equal(Infinity, rule.max)
   end
 
   def test_star
     match = File.parse('*', :root => :star)
     assert(match)
-    assert_equal(0, match.min)
-    assert_equal(Infinity, match.max)
+    rule = match.value('')
+    assert_instance_of(Repeat, rule)
+    assert_equal(0, rule.min)
+    assert_equal(Infinity, rule.max)
   end
 
   def test_n_star
     match = File.parse('1*', :root => :star)
     assert(match)
-    assert_equal(1, match.min)
-    assert_equal(Infinity, match.max)
+    rule = match.value('')
+    assert_instance_of(Repeat, rule)
+    assert_equal(1, rule.min)
+    assert_equal(Infinity, rule.max)
   end
 
   def test_star_n
     match = File.parse('*2', :root => :star)
     assert(match)
-    assert_equal(0, match.min)
-    assert_equal(2, match.max)
+    rule = match.value('')
+    assert_instance_of(Repeat, rule)
+    assert_equal(0, rule.min)
+    assert_equal(2, rule.max)
   end
 
   def test_n_star_n
     match = File.parse('1*2', :root => :star)
     assert(match)
-    assert_equal(1, match.min)
-    assert_equal(2, match.max)
+    rule = match.value('')
+    assert_instance_of(Repeat, rule)
+    assert_equal(1, rule.min)
+    assert_equal(2, rule.max)
   end
 
   def test_n_star_n_space
     match = File.parse('1*2 ', :root => :star)
     assert(match)
-    assert_equal(1, match.min)
-    assert_equal(2, match.max)
+    rule = match.value('')
+    assert_instance_of(Repeat, rule)
+    assert_equal(1, rule.min)
+    assert_equal(2, rule.max)
   end
 
   def test_module_name