citrus 2.1.2 → 2.2.0

data/test/{rule_test.rb → extension_test.rb}

@@ -1,7 +1,6 @@
 require File.expand_path('../helper', __FILE__)
 
-class RuleTest < Test::Unit::TestCase
-
+class ExtensionTest < Test::Unit::TestCase
   module MatchModule
     def a_test
       :test
@@ -16,37 +15,39 @@ class RuleTest < Test::Unit::TestCase
 
   NumericModule = Module.new(&NumericProc)
 
-  def test_create
-    rule = Rule.eval('"a"')
-    assert(rule)
-    match = rule.match(input('a'))
-    assert(match)
-  end
+  NumericProcBare = Proc.new {
+    to_i + 1
+  }
 
   def test_match_module
-    rule = EqualRule.new('a')
+    rule = StringTerminal.new('abc')
     rule.extension = MatchModule
-    match = rule.match(input('a'))
+    match = rule.parse('abc')
     assert(match)
     assert_equal(:test, match.a_test)
   end
 
   def test_numeric_proc
-    rule = EqualRule.new(1)
+    rule = StringTerminal.new('1')
     rule.extension = NumericProc
-    match = rule.match(input('1'))
+    match = rule.parse('1')
     assert(match)
     assert_equal(2, match.add_one)
-    assert_instance_of(Float, match.to_f)
   end
 
   def test_numeric_module
-    rule = EqualRule.new(1)
+    rule = StringTerminal.new('1')
     rule.extension = NumericModule
-    match = rule.match(input('1'))
+    match = rule.parse('1')
     assert(match)
     assert_equal(2, match.add_one)
-    assert_instance_of(Float, match.to_f)
   end
 
+  def test_numeric_proc_bare
+    rule = StringTerminal.new('1')
+    rule.extension = NumericProcBare
+    match = rule.parse('1')
+    assert(match)
+    assert_equal(2, match.value)
+  end
 end

data/test/file_test.rb

@@ -1,324 +1,335 @@
 require File.expand_path('../helper', __FILE__)
-require 'citrus/file'
 
 class CitrusFileTest < Test::Unit::TestCase
 
-  # A shortcut for creating a grammar that includes Citrus::File but uses a
-  # different root.
-  def file(root_rule)
-    Grammar.new do
-      include Citrus::File
-      root root_rule
-    end
-  end
-
   ## File tests
 
   def run_file_test(file, root)
-    grammar = file(root)
-    code = F.read(file)
-    match = grammar.parse(code)
+    match = File.parse(F.read(file), :root => root)
     assert(match)
   end
 
-  %w< rule grammar >.each do |type|
+  %w<rule grammar>.each do |type|
     Dir[F.dirname(__FILE__) + "/_files/#{type}*.citrus"].each do |path|
-      module_eval(<<-RUBY.gsub(/^        /, ''), __FILE__, __LINE__ + 1)
+      module_eval(<<-CODE.gsub(/^        /, ''), __FILE__, __LINE__ + 1)
         def test_#{F.basename(path, '.citrus')}
           run_file_test("#{path}", :#{type})
         end
-      RUBY
+      CODE
     end
   end
 
   ## Hierarchical syntax
 
-  def test_rule_body
-    grammar = file(:rule_body)
-
-    match = grammar.parse('"a" | "b"')
-    assert(match)
-    assert_kind_of(Rule, match.value)
-    assert_instance_of(Choice, match.value)
-
-    match = grammar.parse('rule_name')
+  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
 
-    match = grammar.parse('""')
+  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 = grammar.parse('"a"')
+    match = File.parse('[a-z]', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Terminal, match.value)
 
-    match = grammar.parse('"a" "b"')
+    match = File.parse('/./', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Sequence, match.value)
+    assert_instance_of(Terminal, match.value)
 
-    match = grammar.parse('"a" | "b"')
+    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(Choice, match.value)
+    assert_instance_of(Terminal, match.value)
+  end
 
-    match = grammar.parse('.')
+  def test_rule_body_string_terminal
+    match = File.parse('""', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Terminal, match.value)
+    assert_instance_of(StringTerminal, match.value)
 
-    match = grammar.parse('[a-z]')
+    match = File.parse('"a"', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Terminal, match.value)
+    assert_instance_of(StringTerminal, match.value)
 
-    match = grammar.parse('/./')
+    match = File.parse('"" {}', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Terminal, match.value)
+    assert_instance_of(StringTerminal, match.value)
+  end
 
-    match = grammar.parse('/./ /./')
+  def test_rule_body_repeat
+    match = File.parse('"a"*', :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)
+    assert_instance_of(Repeat, match.value)
+    assert_equal(0, match.value.min)
+    assert_equal(Infinity, match.value.max)
 
-    match = grammar.parse('/./ | /./')
+    match = File.parse('""* {}', :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)
+    assert_instance_of(Repeat, match.value)
 
-    match = grammar.parse('"" {}')
+    match = File.parse('("a" "b")*', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Terminal, match.value)
+    assert_instance_of(Repeat, match.value)
 
-    match = grammar.parse('""* {}')
+    match = File.parse('("a" | "b")*', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
 
-    match = grammar.parse('"a"*')
+    match = File.parse('("a" "b")* {}', :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)
 
-    match = grammar.parse('("a" "b")*')
+    match = File.parse('("a" | "b")* {}', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
 
-    match = grammar.parse('"a" | "b"')
+    match = File.parse('("a" "b")* <Module>', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Choice, match.value)
+    assert_instance_of(Repeat, match.value)
 
-    match = grammar.parse('("a" | "b")*')
+    match = File.parse('( "a" "b" )* <Module>', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
 
-    match = grammar.parse('("a" "b")* {}')
+    match = File.parse('("a" | "b")* <Module>', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
 
-    match = grammar.parse('("a" | "b")* {}')
+    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
 
-    match = grammar.parse('("a" | /./)')
+  def test_rule_body_choice
+    match = File.parse('"a" | "b"', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Choice, match.value)
 
-    match = grammar.parse('"a" ("b" | /./)* {}')
+    match = File.parse('/./ | /./', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Sequence, 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)
 
-    match = grammar.parse('("a" "b")* <Module>')
+    match = File.parse('("a" | /./)', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Repeat, match.value)
+    assert_instance_of(Choice, match.value)
 
-    match = grammar.parse('( "a" "b" )* <Module>')
+    match = File.parse('("a" | "b") <Module>', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Repeat, match.value)
+    assert_instance_of(Choice, match.value)
+  end
 
-    match = grammar.parse('( "a" "b" ) <Module>')
+  def test_rule_body_sequence
+    match = File.parse('"a" "b"', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Sequence, match.value)
 
-    match = grammar.parse('("a" | "b")* <Module>')
-    assert(match)
-    assert_kind_of(Rule, match.value)
-    assert_instance_of(Repeat, match.value)
-
-    match = grammar.parse('("a" | "b") <Module>')
+    match = File.parse('/./ /./', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Choice, match.value)
+    assert_instance_of(Sequence, match.value)
+    assert_equal(2, match.find(:regular_expression).length)
 
-    match = grammar.parse('"a" ("b" | /./)* <Module>')
+    match = File.parse('( "a" "b" ) <Module>', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Sequence, match.value)
 
-    match = grammar.parse("[0-9] {\n  def value\n    text.to_i\n  end\n}\n")
+    match = File.parse('"a" ("b" | /./)* <Module>', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Terminal, match.value)
+    assert_instance_of(Sequence, match.value)
 
-    match = grammar.parse("[0-9]+ {\n  def value\n    text.to_i\n  end\n}\n")
+    match = File.parse('"a" ("b" | /./)* {}', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Repeat, match.value)
+    assert_instance_of(Sequence, match.value)
   end
 
   def test_precedence
-    grammar = file(:rule_body)
-
     # Sequence should bind more tightly than Choice.
-    match = grammar.parse('"a" "b" | "c"')
+    match = File.parse('"a" "b" | "c"', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Choice, match.value)
 
     # Parentheses should change binding precedence.
-    match = grammar.parse('"a" ("b" | "c")')
+    match = File.parse('"a" ("b" | "c")', :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Sequence, match.value)
 
     # Repeat should bind more tightly than AndPredicate.
-    match = grammar.parse("&'a'+")
+    match = File.parse("&'a'+", :root => :rule_body)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(AndPredicate, match.value)
   end
 
-  def test_empty
-    grammar = file(:rule_body)
-
-    match = grammar.parse('')
+  def test_rule_body_empty
+    match = File.parse('', :root => :rule_body)
     assert(match)
   end
 
   def test_choice
-    grammar = file(:choice)
-
-    match = grammar.parse('"a" | "b"')
+    match = File.parse('"a" | "b"', :root => :choice)
     assert(match)
     assert_equal(2, match.rules.length)
     assert_instance_of(Choice, match.value)
+  end
 
-    match = grammar.parse('"a" | ("b" "c")')
+  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
-    grammar = file(:sequence)
-
-    match = grammar.parse('"" ""')
+    match = File.parse('"" ""', :root => :sequence)
     assert(match)
     assert_equal(2, match.rules.length)
     assert_instance_of(Sequence, match.value)
+  end
 
-    match = grammar.parse('"a" "b" "c"')
+  def test_sequence_embedded_choice
+    match = File.parse('"a" ("b" | "c")', :root => :sequence)
     assert(match)
-    assert_equal(3, match.rules.length)
+    assert_equal(2, match.rules.length)
     assert_instance_of(Sequence, match.value)
   end
 
-  def test_expression
-    grammar = file(:expression)
-
-    match = grammar.parse('"" <Module>')
+  def test_expression_tag
+    match = File.parse('"" <Module>', :root => :expression)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_kind_of(Module, match.value.extension)
+  end
 
-    match = grammar.parse('"" {}')
+  def test_expression_block
+    match = File.parse('"" {}', :root => :expression)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_kind_of(Module, match.value.extension)
+  end
 
-    match = grammar.parse('"" {} ')
+  def test_expression_block_space
+    match = File.parse('"" {} ', :root => :expression)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_kind_of(Module, match.value.extension)
   end
 
-  def test_prefix
-    grammar = file(:prefix)
-
-    match = grammar.parse('&""')
+  def test_prefix_and
+    match = File.parse('&""', :root => :prefix)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(AndPredicate, match.value)
+  end
 
-    match = grammar.parse('!""')
+  def test_prefix_not
+    match = File.parse('!""', :root => :prefix)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(NotPredicate, match.value)
+  end
 
-    match = grammar.parse('label:""')
+  def test_prefix_label
+    match = File.parse('label:""', :root => :prefix)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Label, match.value)
+  end
 
-    match = grammar.parse('label :"" ')
+  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)
   end
 
-  def test_suffix
-    grammar = file(:suffix)
+  def test_suffix_plus
+    match = File.parse('""+', :root => :suffix)
+    assert(match)
+    assert_kind_of(Rule, match.value)
+    assert_instance_of(Repeat, match.value)
+  end
 
-    match = grammar.parse('""+')
+  def test_suffix_question
+    match = File.parse('""? ', :root => :suffix)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
+  end
 
-    match = grammar.parse('""? ')
+  def test_suffix_star
+    match = File.parse('""*', :root => :suffix)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Repeat, match.value)
+  end
 
-    match = grammar.parse('""1* ')
+  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_primary
-    grammar = file(:primary)
+  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
 
-    match = grammar.parse('rule_name')
+  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
 
-    match = grammar.parse('"a"')
+  def test_primary_string_terminal
+    match = File.parse('"a"', :root => :primary)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Terminal, match.value)
+    assert_instance_of(StringTerminal, match.value)
   end
 
 
@@ -326,223 +337,279 @@ class CitrusFileTest < Test::Unit::TestCase
 
 
   def test_require
-    grammar = file(:require)
-
-    match = grammar.parse('require "some/file"')
+    match = File.parse('require "some/file"', :root => :require)
     assert(match)
     assert_equal('some/file', match.value)
+  end
 
-    match = grammar.parse('require"some/file"')
+  def test_require_no_space
+    match = File.parse('require"some/file"', :root => :require)
     assert(match)
     assert_equal('some/file', match.value)
+  end
 
-    match = grammar.parse("require 'some/file'")
+  def test_require_single_quoted
+    match = File.parse("require 'some/file'", :root => :require)
     assert(match)
     assert_equal('some/file', match.value)
   end
 
   def test_include
-    grammar = file(:include)
-
-    match = grammar.parse('include Module')
+    match = File.parse('include Module', :root => :include)
     assert(match)
     assert_equal(Module, match.value)
+  end
 
-    match = grammar.parse('include ::Module')
+  def test_include_colon_colon
+    match = File.parse('include ::Module', :root => :include)
     assert(match)
     assert_equal(Module, match.value)
   end
 
   def test_root
-    grammar = file(:root)
-
-    match = grammar.parse('root some_rule')
+    match = File.parse('root some_rule', :root => :root)
     assert(match)
     assert_equal('some_rule', match.value)
+  end
 
+  def test_root_invalid
     assert_raise ParseError do
-      match = grammar.parse('root :a_root')
+      File.parse('root :a_root', :root => :root)
     end
   end
 
   def test_rule_name
-    grammar = file(:rule_name)
-
-    match = grammar.parse('some_rule')
+    match = File.parse('some_rule', :root => :rule_name)
     assert(match)
     assert('some_rule', match.value)
+  end
 
-    match = grammar.parse('some_rule ')
+  def test_rule_name_space
+    match = File.parse('some_rule ', :root => :rule_name)
     assert(match)
     assert('some_rule', match.value)
   end
 
-  def test_terminal
-    grammar = file(:terminal)
-
-    match = grammar.parse('"a"')
+  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)
-    assert(match.value.terminal?)
+  end
 
-    match = grammar.parse('[a-z]')
+  def test_terminal_dot
+    match = File.parse('.', :root => :terminal)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Terminal, match.value)
-    assert(match.value.terminal?)
+  end
 
-    match = grammar.parse('.')
+  def test_terminal_regular_expression
+    match = File.parse('/./', :root => :terminal)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_instance_of(Terminal, match.value)
-    assert(match.value.terminal?)
+  end
 
-    match = grammar.parse('/./')
+  def test_string_terminal_single_quoted
+    match = File.parse("'a'", :root => :string_terminal)
     assert(match)
     assert_kind_of(Rule, match.value)
-    assert_instance_of(Terminal, match.value)
-    assert(match.value.terminal?)
+    assert_instance_of(StringTerminal, match.value)
   end
 
-  def test_single_quoted_string
-    grammar = file(:quoted_string)
+  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
 
-    match = grammar.parse("'test'")
+  def test_single_quoted_string
+    match = File.parse("'test'", :root => :quoted_string)
     assert(match)
     assert_equal('test', match.value)
+  end
 
-    match = grammar.parse("'te\\'st'")
+  def test_single_quoted_string_embedded_single_quote
+    match = File.parse("'te\\'st'", :root => :quoted_string)
     assert(match)
     assert_equal("te'st", match.value)
+  end
 
-    match = grammar.parse("'te\"st'")
+  def test_single_quoted_string_embedded_double_quote
+    match = File.parse("'te\"st'", :root => :quoted_string)
     assert(match)
     assert_equal('te"st', match.value)
   end
 
   def test_double_quoted_string
-    grammar = file(:quoted_string)
-
-    match = grammar.parse('"test"')
+    match = File.parse('"test"', :root => :quoted_string)
     assert(match)
     assert_equal('test', match.value)
+  end
 
-    match = grammar.parse('"te\\"st"')
+  def test_double_quoted_string_embedded_double_quote
+    match = File.parse('"te\\"st"', :root => :quoted_string)
     assert(match)
     assert_equal('te"st', match.value)
+  end
 
-    match = grammar.parse('"te\'st"')
+  def test_double_quoted_string_embedded_single_quote
+    match = File.parse('"te\'st"', :root => :quoted_string)
     assert(match)
     assert_equal("te'st", match.value)
+  end
 
-    match = grammar.parse('"\\x26"')
+  def test_double_quoted_string_hex
+    match = File.parse('"\\x26"', :root => :quoted_string)
     assert(match)
     assert_equal('&', match.value)
   end
 
-  def test_character_class
-    grammar = file(:character_class)
+  def test_case_insensitive_string
+    match = File.parse('`test`', :root => :case_insensitive_string)
+    assert(match)
+    assert_equal('test', match.value)
+  end
+
+  def test_case_insensitive_string_embedded_double_quote
+    match = File.parse('`te\\"st`', :root => :case_insensitive_string)
+    assert(match)
+    assert_equal('te"st', match.value)
+  end
 
-    match = grammar.parse('[_]')
+  def test_case_insensitive_string_embedded_backtick
+    match = File.parse('`te\`st`', :root => :case_insensitive_string)
+    assert(match)
+    assert_equal("te`st", match.value)
+  end
+
+  def test_case_insensitive_string_hex
+    match = File.parse('`\\x26`', :root => :case_insensitive_string)
+    assert(match)
+    assert_equal('&', match.value)
+  end
+
+  def test_character_class
+    match = File.parse('[_]', :root => :character_class)
     assert(match)
     assert_equal(/\A[_]/, match.value)
+  end
 
-    match = grammar.parse('[a-z]')
+  def test_character_class_a_z
+    match = File.parse('[a-z]', :root => :character_class)
     assert(match)
     assert_equal(/\A[a-z]/, match.value)
+  end
 
-    match = grammar.parse('[a-z0-9]')
+  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
 
-    match = grammar.parse('[\[-\]]')
+  def test_character_class_nested_square_brackets
+    match = File.parse('[\[-\]]', :root => :character_class)
     assert(match)
     assert_equal(/\A[\[-\]]/, match.value)
+  end
 
-    match = grammar.parse('[\\x26-\\x29]')
+  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
-    grammar = file(:dot)
-
-    match = grammar.parse('.')
+    match = File.parse('.', :root => :dot)
     assert(match)
     assert_equal(DOT, match.value)
   end
 
   def test_regular_expression
-    grammar = file(:regular_expression)
-
-    match = grammar.parse('/./')
+    match = File.parse('/./', :root => :regular_expression)
     assert(match)
     assert_equal(/./, match.value)
+  end
 
-    match = grammar.parse('/\\//')
+  def test_regular_expression_escaped_forward_slash
+    match = File.parse('/\\//', :root => :regular_expression)
     assert(match)
     assert_equal(/\//, match.value)
+  end
 
-    match = grammar.parse('/\\\\/')
+  def test_regular_expression_escaped_backslash
+    match = File.parse('/\\\\/', :root => :regular_expression)
     assert(match)
     assert_equal(/\\/, match.value)
+  end
 
-    match = grammar.parse('/\\x26/')
+  def test_regular_expression_hex
+    match = File.parse('/\\x26/', :root => :regular_expression)
     assert(match)
     assert_equal(/\x26/, match.value)
+  end
 
-    match = grammar.parse('/a/i')
+  def test_regular_expression_with_flag
+    match = File.parse('/a/i', :root => :regular_expression)
     assert(match)
     assert_equal(/a/i, match.value)
   end
 
-  def test_predicate
-    grammar = file(:predicate)
-
-    match = grammar.parse('&')
+  def test_predicate_and
+    match = File.parse('&', :root => :predicate)
     assert(match)
     assert_kind_of(Rule, match.value(''))
+  end
 
-    match = grammar.parse('!')
+  def test_predicate_not
+    match = File.parse('!', :root => :predicate)
     assert(match)
     assert_kind_of(Rule, match.value(''))
   end
 
   def test_and
-    grammar = file(:and)
-
-    match = grammar.parse('&')
+    match = File.parse('&', :root => :and)
     assert(match)
     assert_instance_of(AndPredicate, match.value(''))
+  end
 
-    match = grammar.parse('& ')
+  def test_and_space
+    match = File.parse('& ', :root => :and)
     assert(match)
     assert_instance_of(AndPredicate, match.value(''))
   end
 
   def test_not
-    grammar = file(:not)
-
-    match = grammar.parse('!')
+    match = File.parse('!', :root => :not)
     assert(match)
     assert_instance_of(NotPredicate, match.value(''))
+  end
 
-    match = grammar.parse('! ')
+  def test_not_space
+    match = File.parse('! ', :root => :not)
     assert(match)
     assert_instance_of(NotPredicate, match.value(''))
   end
 
   def test_label
-    grammar = file(:label)
-
-    match = grammar.parse('label:')
+    match = File.parse('label:', :root => :label)
     assert(match)
     v = match.value('')
     assert_instance_of(Label, v)
     assert_equal(:label, v.label)
+  end
 
-    match = grammar.parse('a_label : ')
+  def test_label_spaced
+    match = File.parse('a_label : ', :root => :label)
     assert(match)
     v = match.value('')
     assert_instance_of(Label, v)
@@ -550,43 +617,51 @@ class CitrusFileTest < Test::Unit::TestCase
   end
 
   def test_tag
-    grammar = file(:tag)
-
-    match = grammar.parse('<Module>')
+    match = File.parse('<Module>', :root => :tag)
     assert(match)
     assert_equal(Module, match.value)
+  end
 
-    match = grammar.parse('< Module >')
+  def test_tag_inner_space
+    match = File.parse('< Module >', :root => :tag)
     assert(match)
     assert_equal(Module, match.value)
+  end
 
-    match = grammar.parse('<Module> ')
+  def test_tag_space
+    match = File.parse('<Module> ', :root => :tag)
     assert(match)
     assert_equal(Module, match.value)
   end
 
   def test_block
-    grammar = file(:block)
-
-    match = grammar.parse('{}')
+    match = File.parse('{}', :root => :block)
     assert(match)
     assert(match.value)
+  end
 
-    match = grammar.parse("{} \n")
+  def test_block_space
+    match = File.parse("{} \n", :root => :block)
     assert(match)
     assert(match.value)
+  end
 
-    match = grammar.parse('{ 2 }')
+  def test_block_n
+    match = File.parse('{ 2 }', :root => :block)
     assert(match)
     assert(match.value)
     assert_equal(2, match.value.call)
+  end
 
-    match = grammar.parse("{ {:a => :b}\n}")
+  def test_block_with_hash
+    match = File.parse("{ {:a => :b}\n}", :root => :block)
     assert(match)
     assert(match.value)
     assert_equal({:a => :b}, match.value.call)
+  end
 
-    match = grammar.parse("{|b|\n  Proc.new(&b)\n}")
+  def test_block_proc
+    match = File.parse("{|b|\n  Proc.new(&b)\n}", :root => :block)
     assert(match)
     assert(match.value)
 
@@ -594,121 +669,152 @@ class CitrusFileTest < Test::Unit::TestCase
 
     assert(b)
     assert_equal(:hi, b.call)
+  end
 
-    match = grammar.parse("{\n  def value\n    'a'\n  end\n} ")
+  def test_block_def
+    match = File.parse("{\n  def value\n    'a'\n  end\n} ", :root => :block)
     assert(match)
     assert(match.value)
-
   end
 
   def test_block_with_interpolation
-    grammar = file(:block)
-
-    match = grammar.parse('{ "#{number}" }')
+    match = File.parse('{ "#{number}" }', :root => :block)
     assert(match)
     assert(match.value)
   end
 
-  def test_repeat
-    grammar = file(:repeat)
+  def test_repeat_question
+    match = File.parse('?', :root => :repeat)
+    assert(match)
+    assert_instance_of(Repeat, match.value(''))
+  end
+
+  def test_repeat_plus
+    match = File.parse('+', :root => :repeat)
+    assert(match)
+    assert_instance_of(Repeat, match.value(''))
+  end
 
-    match = grammar.parse('?')
+  def test_repeat_star
+    match = File.parse('*', :root => :repeat)
     assert(match)
-    assert_instance_of(Repeat, match.wrap(''))
+    assert_instance_of(Repeat, match.value(''))
+  end
 
-    match = grammar.parse('+')
+  def test_repeat_n_star
+    match = File.parse('1*', :root => :repeat)
     assert(match)
-    assert_instance_of(Repeat, match.wrap(''))
+    assert_instance_of(Repeat, match.value(''))
+  end
 
-    match = grammar.parse('*')
+  def test_repeat_star_n
+    match = File.parse('*2', :root => :repeat)
     assert(match)
-    assert_instance_of(Repeat, match.wrap(''))
+    assert_instance_of(Repeat, match.value(''))
   end
 
-  def test_question
-    grammar = file(:question)
+  def test_repeat_n_star_n
+    match = File.parse('1*2', :root => :repeat)
+    assert(match)
+    assert_instance_of(Repeat, match.value(''))
+  end
 
-    match = grammar.parse('?')
+  def test_question
+    match = File.parse('?', :root => :question)
     assert(match)
     assert_equal(0, match.min)
     assert_equal(1, match.max)
+  end
 
-    match = grammar.parse('? ')
+  def test_question_space
+    match = File.parse('? ', :root => :question)
     assert(match)
     assert_equal(0, match.min)
     assert_equal(1, match.max)
   end
 
   def test_plus
-    grammar = file(:plus)
-
-    match = grammar.parse('+')
+    match = File.parse('+', :root => :plus)
     assert(match)
     assert_equal(1, match.min)
     assert_equal(Infinity, match.max)
+  end
 
-    match = grammar.parse('+ ')
+  def test_plus_space
+    match = File.parse('+ ', :root => :plus)
     assert(match)
     assert_equal(1, match.min)
     assert_equal(Infinity, match.max)
   end
 
-  def test_repeat
-    grammar = file(:repeat)
-
-    match = grammar.parse('*')
+  def test_star
+    match = File.parse('*', :root => :star)
     assert(match)
     assert_equal(0, match.min)
     assert_equal(Infinity, match.max)
+  end
 
-    match = grammar.parse('1*')
+  def test_n_star
+    match = File.parse('1*', :root => :star)
     assert(match)
     assert_equal(1, match.min)
     assert_equal(Infinity, match.max)
+  end
 
-    match = grammar.parse('*2')
+  def test_star_n
+    match = File.parse('*2', :root => :star)
     assert(match)
     assert_equal(0, match.min)
     assert_equal(2, match.max)
+  end
 
-    match = grammar.parse('1*2')
+  def test_n_star_n
+    match = File.parse('1*2', :root => :star)
     assert(match)
     assert_equal(1, match.min)
     assert_equal(2, match.max)
+  end
 
-    match = grammar.parse('1*2 ')
+  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)
   end
 
   def test_module_name
-    grammar = file(:module_name)
+    match = File.parse('Module', :root => :module_name)
+    assert(match)
+    assert_equal('Module', match)
+  end
 
-    match = grammar.parse('Module')
+  def test_module_name_space
+    match = File.parse('Module ', :root => :module_name)
     assert(match)
+    assert_equal('Module', match.first)
+  end
 
-    match = grammar.parse('::Proc')
+  def test_module_name_colon_colon
+    match = File.parse('::Proc', :root => :module_name)
     assert(match)
+    assert_equal('::Proc', match)
   end
 
   def test_constant
-    grammar = file(:constant)
-
-    match = grammar.parse('Math')
+    match = File.parse('Math', :root => :constant)
     assert(match)
+    assert_equal('Math', match)
+  end
 
+  def test_constant_invalid
     assert_raise ParseError do
-      match = grammar.parse('math')
+      File.parse('math', :root => :constant)
     end
   end
 
   def test_comment
-    grammar = file(:comment)
-
-    match = grammar.parse('# A comment.')
+    match = File.parse('# A comment.', :root => :comment)
     assert(match)
     assert_equal('# A comment.', match)
   end
-
 end