citrus 2.1.2 → 2.2.0

data/lib/citrus/file.rb

@@ -3,7 +3,7 @@ require 'citrus'
 module Citrus
   # Some helper methods for rules that alias +module_name+ and don't want to
   # use +Kernel#eval+ to retrieve Module objects.
-  module ModuleHelpers #:nodoc:
+  module ModuleNameHelpers #:nodoc:
     def module_segments
       @module_segments ||= module_name.value.split('::')
     end
@@ -35,7 +35,7 @@ module Citrus
 
     rule :grammar do
       all(:grammar_keyword, :module_name, :grammar_body, :end_keyword) {
-        include ModuleHelpers
+        include ModuleNameHelpers
 
         def value
           module_namespace.const_set(module_basename, grammar_body.value)
@@ -78,7 +78,11 @@ module Citrus
     rule :choice do
       all(:sequence, zero_or_more([ :bar, :sequence ])) {
         def rules
-          @rules ||= [ sequence.value ] + matches[1].matches.map {|m| m.matches[1].value }
+          @rules ||= begin
+            [ sequence.value ] + matches[1].matches.map do |m|
+              m.matches[1].value
+            end
+          end
         end
 
         def value
@@ -127,7 +131,7 @@ module Citrus
     end
 
     rule :primary do
-      any(:grouping, :proxy, :terminal)
+      any(:grouping, :proxy, :string_terminal, :terminal)
     end
 
     rule :grouping do
@@ -142,7 +146,7 @@ module Citrus
 
     rule :include do
       all(:include_keyword, :module_name) {
-        include ModuleHelpers
+        include ModuleNameHelpers
 
         def value
           module_namespace.const_get(module_basename)
@@ -176,14 +180,44 @@ module Citrus
       }
     end
 
-    rule :terminal do
-      any(:quoted_string, :character_class, :dot, :regular_expression) {
-        Rule.new(super())
+    rule :string_terminal do
+      any(:quoted_string, :case_insensitive_string) {
+        StringTerminal.new(super(), flags)
       }
     end
 
     rule :quoted_string do
       all(/(["'])(?:\\?.)*?\1/, :space) {
+        def value
+          eval(first)
+        end
+
+        def flags
+          0
+        end
+      }
+    end
+
+    rule :case_insensitive_string do
+      all(/`(?:\\?.)*?`/, :space) {
+        def value
+          eval(first.gsub(/^`|`$/, '"'))
+        end
+
+        def flags
+          Regexp::IGNORECASE
+        end
+      }
+    end
+
+    rule :terminal do
+      any(:regular_expression, :character_class, :dot) {
+        Terminal.new(super())
+      }
+    end
+
+    rule :regular_expression do
+      all(/\/(?:\\?.)*?\/[imxouesn]*/, :space) {
         eval(first)
       }
     end
@@ -200,9 +234,23 @@ module Citrus
       }
     end
 
-    rule :regular_expression do
-      all(/\/(?:\\?.)*?\/[imxouesn]*/, :space) {
-        eval(first)
+    rule :extension do
+      any(:tag, :block)
+    end
+
+    rule :tag do
+      all(:lt, :module_name, :gt) {
+        include ModuleNameHelpers
+
+        def value
+          module_namespace.const_get(module_basename)
+        end
+      }
+    end
+
+    rule :block do
+      all(:lcurly, zero_or_more(any(:block, /[^{}]+/)), :rcurly) {
+        eval('Proc.new ' + to_s, TOPLEVEL_BINDING)
       }
     end
 
@@ -234,26 +282,6 @@ module Citrus
       }
     end
 
-    rule :extension do
-      any(:tag, :block)
-    end
-
-    rule :tag do
-      all(:lt, :module_name, :gt) {
-        include ModuleHelpers
-
-        def value
-          module_namespace.const_get(module_basename)
-        end
-      }
-    end
-
-    rule :block do
-      all(:lcurly, zero_or_more(any(:block, /[^{}]+/)), :rcurly) {
-        eval('Proc.new ' + to_s)
-      }
-    end
-
     rule :repeat do
       any(:question, :plus, :star) { |rule|
         Repeat.new(rule, min, max)
@@ -276,8 +304,13 @@ module Citrus
 
     rule :star do
       all(/[0-9]*/, '*', /[0-9]*/, :space) {
-        def min; matches[0] == '' ? 0 : matches[0].to_i end
-        def max; matches[2] == '' ? Infinity : matches[2].to_i end
+        def min
+          matches[0] == '' ? 0 : matches[0].to_i
+        end
+
+        def max
+          matches[2] == '' ? Infinity : matches[2].to_i
+        end
       }
     end
 

data/test/_files/super.citrus

@@ -4,7 +4,7 @@ grammar SuperOne
   end
 end
 
-grammar SuperTwo
+grammar SuperOneSub
   include SuperOne
 
   rule num

data/test/_files/super2.citrus

@@ -0,0 +1,13 @@
+grammar SuperTwo
+  rule root
+    (one | two) { super() * 1000 }
+  end
+
+  rule one
+    "1" { 1 }
+  end
+
+  rule two
+    "2" { 2 }
+  end
+end

data/test/alias_test.rb

@@ -1,64 +1,48 @@
 require File.expand_path('../helper', __FILE__)
-Citrus.load(File.dirname(__FILE__) + '/_files/alias')
 
 class AliasTest < Test::Unit::TestCase
-
   def test_terminal?
     rule = Alias.new
     assert_equal(false, rule.terminal?)
   end
 
-  def test_match
+  def test_exec
     grammar = Grammar.new {
       rule :a, :b
-      rule :b, 'b'
+      rule :b, 'abc'
     }
-
-    match = grammar.parse('b')
-    assert(match)
-    assert_equal('b', match)
-    assert_equal(1, match.length)
+    rule = grammar.rule(:a)
+    rule_b = grammar.rule(:b)
+    events = rule.exec(Input.new('abc'))
+    assert_equal([rule_b.id, CLOSE, 3], events)
   end
 
-  def test_match_renamed
+  def test_exec_miss
     grammar = Grammar.new {
-      rule :a, ext(:b) {
-        'a' + to_s
-      }
-      rule :b, 'b'
+      rule :a, :b
+      rule :b, 'abc'
     }
-
-    match = grammar.parse('b')
-    assert(match)
-    assert('ab', match.value)
-
-    assert_raise NoMatchError do
-      match.b
-    end
+    rule = grammar.rule(:a)
+    events = rule.exec(Input.new('def'))
+    assert_equal([], events)
   end
 
-  def test_peg
-    match = AliasOne.parse('a')
-    assert(match)
-  end
-
-  def test_included
+  def test_exec_included
     grammar1 = Grammar.new {
-      rule :a, 'a'
+      rule :a, 'abc'
     }
-
     grammar2 = Grammar.new {
       include grammar1
       rule :b, :a
     }
-
-    match = grammar2.parse('a')
-    assert(match)
+    rule = grammar2.rule(:b)
+    rule_a = grammar1.rule(:a)
+    events = rule.exec(Input.new('abc'))
+    assert_equal([rule_a.id, CLOSE, 3], events)
   end
 
   def test_to_s
     rule = Alias.new(:alpha)
     assert_equal('alpha', rule.to_s)
   end
-
 end

data/test/and_predicate_test.rb

@@ -1,27 +1,32 @@
 require File.expand_path('../helper', __FILE__)
 
 class AndPredicateTest < Test::Unit::TestCase
-
   def test_terminal?
     rule = AndPredicate.new
     assert_equal(false, rule.terminal?)
   end
 
-  def test_match
-    rule = AndPredicate.new('a')
+  def test_exec
+    rule = AndPredicate.new('abc')
+    events = rule.exec(Input.new('abc'))
+    assert_equal([rule.id, CLOSE, 0], events)
+  end
 
-    match = rule.match(input('b'))
-    assert_equal(nil, match)
+  def test_exec_miss
+    rule = AndPredicate.new('def')
+    events = rule.exec(Input.new('abc'))
+    assert_equal([], events)
+  end
 
-    match = rule.match(input('a'))
-    assert(match)
-    assert_equal('', match)
-    assert_equal(0, match.length)
+  def test_consumption
+    rule = AndPredicate.new('abc')
+    input = Input.new('abc')
+    events = rule.exec(input)
+    assert_equal(0, input.pos)
   end
 
   def test_to_s
     rule = AndPredicate.new('a')
     assert_equal('&"a"', rule.to_s)
   end
-
 end

data/test/but_predicate_test.rb

@@ -1,36 +1,41 @@
 require File.expand_path('../helper', __FILE__)
 
 class ButPredicateTest < Test::Unit::TestCase
-
   def test_terminal?
     rule = ButPredicate.new
     assert_equal(false, rule.terminal?)
   end
 
-  def test_match
-    rule = ButPredicate.new('a')
+  def test_exec
+    rule = ButPredicate.new('abc')
 
-    match = rule.match(input('b'))
-    assert(match)
-    assert_equal('b', match)
-    assert_equal(1, match.length)
+    events = rule.exec(Input.new('def'))
+    assert_equal([rule.id, CLOSE, 3], events)
 
-    match = rule.match(input('bbba'))
-    assert(match)
-    assert_equal('bbb', match)
-    assert_equal(3, match.length)
+    events = rule.exec(Input.new('defabc'))
+    assert_equal([rule.id, CLOSE, 3], events)
+  end
 
-    match = rule.match(input('a'))
-    assert_equal(nil, match)
+  def test_exec_miss
+    rule = ButPredicate.new('abc')
+    events = rule.exec(Input.new('abc'))
+    assert_equal([], events)
+  end
 
-    # ButPredicate must match at least one character.
-    match = rule.match(input(''))
-    assert_equal(nil, match)
+  def test_consumption
+    rule = ButPredicate.new('abc')
+
+    input = Input.new('def')
+    events = rule.exec(input)
+    assert_equal(3, input.pos)
+
+    input = Input.new('defabc')
+    events = rule.exec(input)
+    assert_equal(3, input.pos)
   end
 
   def test_to_s
     rule = ButPredicate.new('a')
     assert_equal('~"a"', rule.to_s)
   end
-
 end

data/test/calc_file_test.rb

@@ -4,7 +4,7 @@ if defined?(Calc)
   Object.__send__(:remove_const, :Calc)
 end
 
-Citrus.load(File.dirname(__FILE__) + '/../examples/calc')
+Citrus.load File.expand_path('../../examples/calc', __FILE__)
 
 class CalcFileTest < Test::Unit::TestCase
   include CalcTestMethods

data/test/choice_test.rb

@@ -1,50 +1,26 @@
 require File.expand_path('../helper', __FILE__)
 
 class ChoiceTest < Test::Unit::TestCase
-
   def test_terminal?
     rule = Choice.new
     assert_equal(false, rule.terminal?)
   end
 
-  def test_match
-    rule = Choice.new(%w<a b>)
-
-    match = rule.match(input(''))
-    assert_equal(nil, match)
+  def test_exec
+    a = Rule.new('a')
+    b = Rule.new('b')
+    rule = Choice.new([ a, b ])
 
-    match = rule.match(input('a'))
-    assert(match)
-    assert_equal('a', match)
-    assert_equal(1, match.length)
-  end
-
-  def test_match_multi
-    rule = Choice.new(%w<a b>)
+    events = rule.exec(Input.new(''))
+    assert_equal([], events)
 
-    match = rule.match(input('ab'))
-    assert(match)
-    assert_equal('a', match)
-    assert_equal(1, match.length)
+    events = rule.exec(Input.new('a'))
+    assert(events)
+    assert_equal([rule.id, a.id, CLOSE, 1, CLOSE, 1], events)
 
-    match = rule.match(input('ba'))
-    assert(match)
-    assert_equal('b', match)
-    assert_equal(1, match.length)
-  end
-
-  def test_match_embed
-    rule = Choice.new([ /\d+/, Choice.new(%w<+ ->) ])
-
-    match = rule.match(input('1+'))
-    assert(match)
-    assert_equal('1', match)
-    assert_equal(1, match.length)
-
-    match = rule.match(input('+1'))
-    assert(match)
-    assert_equal('+', match)
-    assert_equal(1, match.length)
+    events = rule.exec(Input.new('b'))
+    assert(events)
+    assert_equal([rule.id, b.id, CLOSE, 1, CLOSE, 1], events)
   end
 
   def test_to_s
@@ -58,5 +34,4 @@ class ChoiceTest < Test::Unit::TestCase
     rule = Choice.new([rule1, rule2])
     assert_equal('("a" | "b") | ("c" | "d")', rule.to_s)
   end
-
 end