citrus 2.3.2 → 2.3.3

data/lib/citrus/file.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'citrus'
 
 module Citrus
@@ -9,7 +11,7 @@ module Citrus
     end
 
     def module_namespace
-      module_segments[0..-2].inject(Object) do |namespace, constant|
+      module_segments[0...-1].inject(Object) do |namespace, constant|
         constant.empty? ? namespace : namespace.const_get(constant)
       end
     end
@@ -28,88 +30,71 @@ module Citrus
 
     rule :file do
       all(:space, zero_or_more(any(:require, :grammar))) {
-        if captures[:require]
-          captures[:require].each {|r| require r.value }
+        captures[:require].each do |req|
+          file = req.value
+          begin
+            require file
+          rescue ::LoadError => e
+            begin
+              Citrus.require(file)
+            rescue LoadError
+              # Re-raise the original LoadError.
+              raise e
+            end
+          end
         end
 
-        (captures[:grammar] || []).map {|g| g.value }
+        captures[:grammar].map {|g| g.value }
       }
     end
 
     rule :grammar do
-      mod all(:grammar_keyword, :module_name, :grammar_body, :end_keyword) do
+      mod all(:grammar_keyword, :module_name, zero_or_more(any(:include, :root, :rule)), :end_keyword) do
         include ModuleNameHelpers
 
         def value
-          module_namespace.const_set(module_basename, grammar_body.value)
-        end
-      end
-    end
-
-    rule :grammar_body do
-      zero_or_more(any(:include, :root, :rule)) {
-        grammar = Grammar.new
+          grammar = module_namespace.const_set(module_basename, Grammar.new)
 
-        if captures[:include]
           captures[:include].each {|inc| grammar.include(inc.value) }
-        end
+          captures[:rule].each {|r| grammar.rule(r.rule_name.value, r.value) }
 
-        grammar.root(root.value) if root
+          grammar.root(root.value) if root
 
-        if captures[:rule]
-          captures[:rule].each {|r| grammar.rule(r.rule_name.value, r.value) }
+          grammar
         end
-
-        grammar
-      }
+      end
     end
 
     rule :rule do
-      all(:rule_keyword, :rule_name, :rule_body, :end_keyword) {
-        rule_body.value
-      }
-    end
-
-    rule :rule_body do
-      zero_or_one(:choice) {
+      all(:rule_keyword, :rule_name, zero_or_one(:expression), :end_keyword) {
         # An empty rule definition matches the empty string.
-        choice ? choice.value : Rule.for('')
+        expression ? expression.value : Rule.for('')
       }
     end
 
-    rule :choice do
-      mod all(:sequence, zero_or_more([ :bar, :sequence ])) do
-        def rules
-          @rules ||= captures[:sequence].map {|s| s.value }
-        end
-
-        def value
-          rules.length > 1 ? Choice.new(rules) : rules.first
-        end
-      end
+    rule :expression do
+      all(:sequence, zero_or_more([ :bar, :sequence ])) {
+        rules = captures[:sequence].map {|s| s.value }
+        rules.length > 1 ? Choice.new(rules) : rules.first
+      }
     end
 
     rule :sequence do
-      mod one_or_more(:label_expression) do
-        def rules
-          @rules ||= captures[:label_expression].map {|e| e.value }
-        end
-
-        def value
-          rules.length > 1 ? Sequence.new(rules) : rules.first
-        end
-      end
+      one_or_more(:labelled) {
+        rules = captures[:labelled].map {|l| l.value }
+        rules.length > 1 ? Sequence.new(rules) : rules.first
+      }
     end
 
-    rule :label_expression do
-      all(zero_or_one(:label), :expression) {
-        rule = expression.value
+    rule :labelled do
+      all(zero_or_one(:label), :extended) {
+        rule = extended.value
         rule.label = label.value if label
         rule
       }
     end
 
-    rule :expression do
+    rule :extended do
       all(:prefix, zero_or_one(:extension)) {
         rule = prefix.value
         rule.extension = extension.value if extension
@@ -138,8 +123,8 @@ module Citrus
     end
 
     rule :grouping do
-      all(:lparen, :rule_body, :rparen) {
-        rule_body.value
+      all(:lparen, :expression, :rparen) {
+        expression.value
       }
     end
 
@@ -192,12 +177,14 @@ module Citrus
     end
 
     rule :terminal do
-      any(:string_terminal, :regular_expression, :character_class, :dot)
-    end
+      any(:quoted_string, :case_insensitive_string, :regular_expression, :character_class, :dot) {
+        primitive = super()
 
-    rule :string_terminal do
-      any(:quoted_string, :case_insensitive_string) {
-        StringTerminal.new(super(), flags)
+        if String === primitive
+          StringTerminal.new(primitive, flags)
+        else
+          Terminal.new(primitive)
+        end
       }
     end
 
@@ -227,19 +214,19 @@ module Citrus
 
     rule :regular_expression do
       all(/\/(?:\\?.)*?\/[imxouesn]*/, :space) {
-        Terminal.new(eval(first.to_s))
+        eval(first.to_s)
       }
     end
 
     rule :character_class do
       all(/\[(?:\\?.)*?\]/, :space) {
-        Terminal.new(Regexp.new(first.to_s, nil, 'n'))
+        eval("/#{first.to_s}/")
       }
     end
 
     rule :dot do
       all('.', :space) {
-        Terminal.new(DOT)
+        DOT
       }
     end
 
@@ -317,8 +304,8 @@ module Citrus
 
     rule :star do
       all(/[0-9]*/, '*', /[0-9]*/, :space) { |rule|
-        min = captures[0] == '' ? 0 : captures[0].to_i
-        max = captures[2] == '' ? Infinity : captures[2].to_i
+        min = captures[1] == '' ? 0 : captures[1].to_i
+        max = captures[3] == '' ? Infinity : captures[3].to_i
         Repeat.new(rule, min, max)
       }
     end
@@ -348,4 +335,11 @@ module Citrus
     rule :comment,          /#.*/
     rule :space,            zero_or_more(any(:white, :comment))
   end
+
+  def File.parse(*args) # :nodoc:
+    super
+  rescue ParseError => e
+    # Raise SyntaxError when a parse fails.
+    raise SyntaxError, e
+  end
 end

data/lib/citrus/version.rb

@@ -0,0 +1,9 @@
+module Citrus
+  # The current version of Citrus as [major, minor, patch].
+  VERSION = [2, 3, 3]
+
+  # Returns the current version of Citrus as a string.
+  def self.version
+    VERSION.join('.')
+  end
+end

data/test/alias_test.rb

@@ -46,7 +46,7 @@ class AliasTest < Test::Unit::TestCase
     assert_equal('alpha', rule.to_s)
   end
 
-  def test_to_s
+  def test_to_s_with_label
     rule = Alias.new(:alpha)
     rule.label = 'a_label'
     assert_equal('a_label:alpha', rule.to_s)

data/test/file_test.rb

@@ -21,194 +21,189 @@ class CitrusFileTest < Test::Unit::TestCase
 
   ## Hierarchical syntax
 
-  def test_rule_body_alias
-    match = File.parse('rule_name', :root => :rule_body)
+  def test_expression_empty
+    assert_raise SyntaxError do
+      File.parse('', :root => :expression)
+    end
+  end
+
+  def test_expression_alias
+    match = File.parse('rule_name', :root => :expression)
     assert(match)
     assert_instance_of(Alias, match.value)
   end
 
-  def test_rule_body_dot
-    match = File.parse('.', :root => :rule_body)
+  def test_expression_dot
+    match = File.parse('.', :root => :expression)
     assert(match)
     assert_instance_of(Terminal, match.value)
   end
 
-  def test_rule_body_character_range
-    match = File.parse('[a-z]', :root => :rule_body)
+  def test_expression_character_range
+    match = File.parse('[a-z]', :root => :expression)
     assert(match)
     assert_instance_of(Terminal, match.value)
   end
 
-  def test_rule_body_terminal
-    match = File.parse('/./', :root => :rule_body)
+  def test_expression_terminal
+    match = File.parse('/./', :root => :expression)
     assert(match)
     assert_instance_of(Terminal, match.value)
   end
 
-  def test_rule_body_string_terminal_empty
-    match = File.parse('""', :root => :rule_body)
+  def test_expression_string_terminal_empty
+    match = File.parse('""', :root => :expression)
     assert(match)
     assert_instance_of(StringTerminal, match.value)
   end
 
-  def test_rule_body_string_terminal
-    match = File.parse('"a"', :root => :rule_body)
+  def test_expression_string_terminal
+    match = File.parse('"a"', :root => :expression)
     assert(match)
     assert_instance_of(StringTerminal, match.value)
   end
 
-  def test_rule_body_string_terminal_empty_block
-    match = File.parse('"" {}', :root => :rule_body)
+  def test_expression_string_terminal_empty_block
+    match = File.parse('"" {}', :root => :expression)
     assert(match)
     assert_instance_of(StringTerminal, match.value)
   end
 
-  def test_rule_body_repeat_string_terminal
-    match = File.parse('"a"*', :root => :rule_body)
+  def test_expression_repeat_string_terminal
+    match = File.parse('"a"*', :root => :expression)
     assert(match)
     assert_instance_of(Repeat, match.value)
   end
 
-  def test_rule_body_repeat_empty_string_terminal_block
-    match = File.parse('""* {}', :root => :rule_body)
+  def test_expression_repeat_empty_string_terminal_block
+    match = File.parse('""* {}', :root => :expression)
     assert(match)
     assert_instance_of(Repeat, match.value)
   end
 
-  def test_rule_body_repeat_sequence
-    match = File.parse('("a" "b")*', :root => :rule_body)
+  def test_expression_repeat_sequence
+    match = File.parse('("a" "b")*', :root => :expression)
     assert(match)
     assert_instance_of(Repeat, match.value)
   end
 
-  def test_rule_body_repeat_choice
-    match = File.parse('("a" | "b")*', :root => :rule_body)
+  def test_expression_repeat_choice
+    match = File.parse('("a" | "b")*', :root => :expression)
     assert(match)
     assert_instance_of(Repeat, match.value)
   end
 
-  def test_rule_body_repeat_sequence_block
-    match = File.parse('("a" "b")* {}', :root => :rule_body)
+  def test_expression_repeat_sequence_block
+    match = File.parse('("a" "b")* {}', :root => :expression)
     assert(match)
     assert_instance_of(Repeat, match.value)
   end
 
-  def test_rule_body_repeat_choice_block
-    match = File.parse('("a" | "b")* {}', :root => :rule_body)
+  def test_expression_repeat_choice_block
+    match = File.parse('("a" | "b")* {}', :root => :expression)
     assert(match)
     assert_instance_of(Repeat, match.value)
   end
 
-  def test_rule_body_repeat_sequence_extension
-    match = File.parse('("a" "b")* <Module>', :root => :rule_body)
+  def test_expression_repeat_sequence_extension
+    match = File.parse('("a" "b")* <Module>', :root => :expression)
     assert(match)
     assert_instance_of(Repeat, match.value)
   end
 
-  def test_rule_body_repeat_sequence_extension_spaced
-    match = File.parse('( "a" "b" )* <Module>', :root => :rule_body)
+  def test_expression_repeat_sequence_extension_spaced
+    match = File.parse('( "a" "b" )* <Module>', :root => :expression)
     assert(match)
     assert_instance_of(Repeat, match.value)
   end
 
-  def test_rule_body_repeat_choice_extension
-    match = File.parse('("a" | "b")* <Module>', :root => :rule_body)
+  def test_expression_repeat_choice_extension
+    match = File.parse('("a" | "b")* <Module>', :root => :expression)
     assert(match)
     assert_instance_of(Repeat, match.value)
   end
 
-  def test_rule_body_choice_terminal
-    match = File.parse('/./ | /./', :root => :rule_body)
+  def test_expression_choice_terminal
+    match = File.parse('/./ | /./', :root => :expression)
+    assert(match)
+    assert_instance_of(Choice, match.value)
+  end
+
+  def test_expression_choice_string_terminal
+    match = File.parse('"a" | "b"', :root => :expression)
     assert(match)
     assert_instance_of(Choice, match.value)
   end
 
-  def test_rule_body_choice_string_terminal
-    match = File.parse('"a" | "b"', :root => :rule_body)
+  def test_expression_choice_embedded_sequence
+    match = File.parse('"a" | ("b" "c")', :root => :expression)
     assert(match)
     assert_instance_of(Choice, match.value)
   end
 
-  def test_rule_body_choice_mixed
-    match = File.parse('("a" | /./)', :root => :rule_body)
+  def test_expression_choice_mixed
+    match = File.parse('("a" | /./)', :root => :expression)
     assert(match)
     assert_instance_of(Choice, match.value)
   end
 
-  def test_rule_body_choice_extended
-    match = File.parse('("a" | "b") <Module>', :root => :rule_body)
+  def test_expression_choice_extended
+    match = File.parse('("a" | "b") <Module>', :root => :expression)
     assert(match)
     assert_instance_of(Choice, match.value)
   end
 
-  def test_rule_body_sequence_terminal
-    match = File.parse('/./ /./', :root => :rule_body)
+  def test_expression_sequence_terminal
+    match = File.parse('/./ /./', :root => :expression)
     assert(match)
     assert_instance_of(Sequence, match.value)
   end
 
-  def test_rule_body_sequence_string_terminal
-    match = File.parse('"a" "b"', :root => :rule_body)
+  def test_expression_sequence_string_terminal
+    match = File.parse('"a" "b"', :root => :expression)
     assert(match)
     assert_instance_of(Sequence, match.value)
   end
 
-  def test_rule_body_sequence_extension
-    match = File.parse('( "a" "b" ) <Module>', :root => :rule_body)
+  def test_expression_sequence_extension
+    match = File.parse('( "a" "b" ) <Module>', :root => :expression)
     assert(match)
     assert_instance_of(Sequence, match.value)
   end
 
-  def test_rule_body_sequence_mixed
-    match = File.parse('"a" ("b" | /./)* <Module>', :root => :rule_body)
+  def test_expression_sequence_mixed
+    match = File.parse('"a" ("b" | /./)* <Module>', :root => :expression)
     assert(match)
     assert_instance_of(Sequence, match.value)
   end
 
-  def test_rule_body_sequence_block
-    match = File.parse('"a" ("b" | /./)* {}', :root => :rule_body)
+  def test_expression_sequence_block
+    match = File.parse('"a" ("b" | /./)* {}', :root => :expression)
     assert(match)
     assert_instance_of(Sequence, match.value)
   end
 
   def test_precedence_sequence_before_choice
     # Sequence should bind more tightly than Choice.
-    match = File.parse('"a" "b" | "c"', :root => :rule_body)
+    match = File.parse('"a" "b" | "c"', :root => :expression)
     assert(match)
     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)
+    match = File.parse('"a" ("b" | "c")', :root => :expression)
     assert(match)
     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)
+    match = File.parse("&'a'+", :root => :expression)
     assert(match)
     assert_instance_of(AndPredicate, match.value)
   end
 
-  def test_rule_body_empty
-    match = File.parse('', :root => :rule_body)
-    assert(match)
-  end
-
-  def test_choice
-    match = File.parse('"a" | "b"', :root => :choice)
-    assert(match)
-    assert_instance_of(Choice, match.value)
-  end
-
-  def test_choice_embedded_sequence
-    match = File.parse('"a" | ("b" "c")', :root => :choice)
-    assert(match)
-    assert_instance_of(Choice, match.value)
-  end
-
   def test_sequence
     match = File.parse('"" ""', :root => :sequence)
     assert(match)
@@ -221,34 +216,21 @@ class CitrusFileTest < Test::Unit::TestCase
     assert_instance_of(Sequence, match.value)
   end
 
-  def test_label_expression
-    match = File.parse('label:""', :root => :label_expression)
+  def test_labelled
+    match = File.parse('label:""', :root => :labelled)
     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)
+  def test_extended_tag
+    match = File.parse('"" <Module>', :root => :extended)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_kind_of(Module, match.value.extension)
   end
 
-  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
-
-  def test_expression_block_space
-    match = File.parse('"" {} ', :root => :expression)
+  def test_extended_block
+    match = File.parse('"" {}', :root => :extended)
     assert(match)
     assert_kind_of(Rule, match.value)
     assert_kind_of(Module, match.value.extension)
@@ -361,7 +343,7 @@ class CitrusFileTest < Test::Unit::TestCase
   end
 
   def test_root_invalid
-    assert_raise ParseError do
+    assert_raise SyntaxError do
       File.parse('root :a_root', :root => :root)
     end
   end
@@ -378,40 +360,40 @@ class CitrusFileTest < Test::Unit::TestCase
     assert('some_rule', match.value)
   end
 
-  def test_terminal_character_class
-    match = File.parse('[a-z]', :root => :terminal)
+  def test_terminal_single_quoted_string
+    match = File.parse("'a'", :root => :terminal)
     assert(match)
-    assert_instance_of(Terminal, match.value)
+    assert_instance_of(StringTerminal, match.value)
   end
 
-  def test_terminal_dot
-    match = File.parse('.', :root => :terminal)
+  def test_terminal_double_quoted_string
+    match = File.parse('"a"', :root => :terminal)
     assert(match)
-    assert_instance_of(Terminal, match.value)
+    assert_instance_of(StringTerminal, match.value)
   end
 
-  def test_terminal_regular_expression
-    match = File.parse('/./', :root => :terminal)
+  def test_terminal_case_insensitive_string
+    match = File.parse('`a`', :root => :terminal)
     assert(match)
-    assert_instance_of(Terminal, match.value)
+    assert_instance_of(StringTerminal, match.value)
   end
 
-  def test_string_terminal_single_quoted
-    match = File.parse("'a'", :root => :string_terminal)
+  def test_terminal_regular_expression
+    match = File.parse('/./', :root => :terminal)
     assert(match)
-    assert_instance_of(StringTerminal, match.value)
+    assert_instance_of(Terminal, match.value)
   end
 
-  def test_string_terminal_double_quoted
-    match = File.parse('"a"', :root => :string_terminal)
+  def test_terminal_character_class
+    match = File.parse('[a-z]', :root => :terminal)
     assert(match)
-    assert_instance_of(StringTerminal, match.value)
+    assert_instance_of(Terminal, match.value)
   end
 
-  def test_string_terminal_case_insensitive
-    match = File.parse('`a`', :root => :string_terminal)
+  def test_terminal_dot
+    match = File.parse('.', :root => :terminal)
     assert(match)
-    assert_instance_of(StringTerminal, match.value)
+    assert_instance_of(Terminal, match.value)
   end
 
   def test_single_quoted_string
@@ -483,81 +465,61 @@ class CitrusFileTest < Test::Unit::TestCase
   def test_regular_expression
     match = File.parse('/./', :root => :regular_expression)
     assert(match)
-    rule = match.value
-    assert_instance_of(Terminal, rule)
-    assert_equal(/./, rule.regexp)
+    assert_equal(/./, match.value)
   end
 
   def test_regular_expression_escaped_forward_slash
     match = File.parse('/\\//', :root => :regular_expression)
     assert(match)
-    rule = match.value
-    assert_instance_of(Terminal, rule)
-    assert_equal(/\//, rule.regexp)
+    assert_equal(/\//, match.value)
   end
 
   def test_regular_expression_escaped_backslash
     match = File.parse('/\\\\/', :root => :regular_expression)
     assert(match)
-    rule = match.value
-    assert_instance_of(Terminal, rule)
-    assert_equal(/\\/, rule.regexp)
+    assert_equal(/\\/, match.value)
   end
 
   def test_regular_expression_hex
     match = File.parse('/\\x26/', :root => :regular_expression)
     assert(match)
-    rule = match.value
-    assert_instance_of(Terminal, rule)
-    assert_equal(/\x26/, rule.regexp)
+    assert_equal(/\x26/, match.value)
   end
 
   def test_regular_expression_with_flag
     match = File.parse('/a/i', :root => :regular_expression)
     assert(match)
-    rule = match.value
-    assert_instance_of(Terminal, rule)
-    assert_equal(/a/i, rule.regexp)
+    assert_equal(/a/i, match.value)
   end
 
   def test_character_class
     match = File.parse('[_]', :root => :character_class)
     assert(match)
-    rule = match.value
-    assert_instance_of(Terminal, rule)
-    assert_equal(/[_]/n, rule.regexp)
+    assert_equal(/[_]/n, match.value)
   end
 
   def test_character_class_a_z
     match = File.parse('[a-z]', :root => :character_class)
     assert(match)
-    rule = match.value
-    assert_instance_of(Terminal, rule)
-    assert_equal(/[a-z]/n, rule.regexp)
+    assert_equal(/[a-z]/n, match.value)
   end
 
   def test_character_class_nested_square_brackets
     match = File.parse('[\[-\]]', :root => :character_class)
     assert(match)
-    rule = match.value
-    assert_instance_of(Terminal, rule)
-    assert_equal(/[\[-\]]/n, rule.regexp)
+    assert_equal(/[\[-\]]/n, match.value)
   end
 
   def test_character_class_hex_range
     match = File.parse('[\\x26-\\x29]', :root => :character_class)
     assert(match)
-    rule = match.value
-    assert_instance_of(Terminal, rule)
-    assert_equal(/[\x26-\x29]/, rule.regexp)
+    assert_equal(/[\x26-\x29]/, match.value)
   end
 
   def test_dot
     match = File.parse('.', :root => :dot)
     assert(match)
-    rule = match.value
-    assert_instance_of(Terminal, rule)
-    assert_equal(DOT, rule.regexp)
+    assert_equal(DOT, match.value)
   end
 
   def test_label
@@ -847,7 +809,7 @@ class CitrusFileTest < Test::Unit::TestCase
   end
 
   def test_constant_invalid
-    assert_raise ParseError do
+    assert_raise SyntaxError do
       File.parse('math', :root => :constant)
     end
   end