citrus 2.1.2 → 2.2.0

data/test/grammar_test.rb

@@ -1,17 +1,10 @@
 require File.expand_path('../helper', __FILE__)
 
 class GrammarTest < Test::Unit::TestCase
-
   def test_new
-    g = Grammar.new
-    assert_kind_of(Module, g)
-    assert(g.include?(Grammar))
-  end
-
-  def test_non_module_fail
-    assert_raise ArgumentError do
-      ''.extend(GrammarMethods)
-    end
+    grammar = Grammar.new
+    assert_kind_of(Module, grammar)
+    assert(grammar.include?(Grammar))
   end
 
   def test_name
@@ -72,6 +65,8 @@ class GrammarTest < Test::Unit::TestCase
     }
     match = grammar.parse('1234')
     assert(match)
+    assert_equal('123', match)
+    assert_equal(3, match.length)
   end
 
   def test_parse_sequence_short
@@ -135,5 +130,4 @@ class GrammarTest < Test::Unit::TestCase
       grammar(:abc)
     end
   end
-
 end

data/test/helper.rb

@@ -2,15 +2,11 @@ lib = File.expand_path('../../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'test/unit'
-require 'citrus/debug'
+require 'citrus'
 
 class Test::Unit::TestCase
   include Citrus
 
-  def input(str='')
-    Input.new(str)
-  end
-
   TestGrammar = Grammar.new do
     rule :alpha do
       /[a-zA-Z]/
@@ -49,18 +45,6 @@ class Test::Unit::TestCase
     end
   end
 
-  class EqualRule
-    include Citrus::Rule
-
-    def initialize(value)
-      @value = value
-    end
-
-    def match(input)
-      create_match(@value.to_s.dup) if @value.to_s == input.string
-    end
-  end
-
   module CalcTestMethods
     # A helper method that tests the successful parsing and evaluation of the
     # given mathematical expression.

data/test/input_test.rb

@@ -1,8 +1,13 @@
 require File.expand_path('../helper', __FILE__)
 
 class InputTest < Test::Unit::TestCase
+  def test_memoized?
+    input = Input.new('')
+    input.memoize!
+    assert(input.memoized?)
+  end
 
-  def test_new_input
+  def test_offsets_new
     input = Input.new("abc\ndef\nghi")
     assert_equal(0, input.line_offset)
     assert_equal(0, input.line_index)
@@ -10,7 +15,7 @@ class InputTest < Test::Unit::TestCase
     assert_equal("abc\n", input.line)
   end
 
-  def test_advanced_input
+  def test_offsets_advanced
     input = Input.new("abc\ndef\nghi")
     input.pos = 6
     assert_equal(2, input.line_offset)
@@ -19,4 +24,169 @@ class InputTest < Test::Unit::TestCase
     assert_equal("def\n", input.line)
   end
 
+  def test_events
+    a = Rule.new('a')
+    b = Rule.new('b')
+    c = Rule.new('c')
+    s = Rule.new([ a, b, c ])
+    r = Repeat.new(s, 0, Infinity)
+
+    input = Input.new("abcabcabc")
+    events = input.exec(r)
+
+    expected_events = [
+      r.id,
+        s.id,
+          a.id, CLOSE, 1,
+          b.id, CLOSE, 1,
+          c.id, CLOSE, 1,
+        CLOSE, 3,
+        s.id,
+          a.id, CLOSE, 1,
+          b.id, CLOSE, 1,
+          c.id, CLOSE, 1,
+        CLOSE, 3,
+        s.id,
+          a.id, CLOSE, 1,
+          b.id, CLOSE, 1,
+          c.id, CLOSE, 1,
+        CLOSE, 3,
+      CLOSE, 9
+    ]
+
+    assert_equal(expected_events, events)
+  end
+
+  def test_events2
+    a = Rule.new('a')
+    b = Rule.new('b')
+    c = Choice.new([ a, b ])
+    r = Repeat.new(c, 0, Infinity)
+    s = Rule.new([ a, r ])
+
+    input = Input.new('abbababba')
+    events = input.exec(s)
+
+    expected_events = [
+      s.id,
+        a.id, CLOSE, 1,
+        r.id,
+          c.id,
+            b.id, CLOSE, 1,
+          CLOSE, 1,
+          c.id,
+            b.id, CLOSE, 1,
+          CLOSE, 1,
+          c.id,
+            a.id, CLOSE, 1,
+          CLOSE, 1,
+          c.id,
+            b.id, CLOSE, 1,
+          CLOSE, 1,
+          c.id,
+            a.id, CLOSE, 1,
+          CLOSE, 1,
+          c.id,
+            b.id, CLOSE, 1,
+          CLOSE, 1,
+          c.id,
+            b.id, CLOSE, 1,
+          CLOSE, 1,
+          c.id,
+            a.id, CLOSE, 1,
+          CLOSE, 1,
+        CLOSE, 8,
+      CLOSE, 9
+    ]
+
+    assert_equal(expected_events, events)
+  end
+
+  grammar :LetterA do
+    rule :top do
+      any(:three_as, :two_as, :one_a)
+    end
+
+    rule :three_as do
+      rep(:one_a, 3, 3)
+    end
+
+    rule :two_as do
+      rep(:one_a, 2, 2)
+    end
+
+    rule :one_a do
+      "a"
+    end
+  end
+
+  def test_cache_hits1
+    input = Input.new('a')
+    input.memoize!
+    input.exec(LetterA.rule(:top))
+    assert_equal(3, input.cache_hits)
+  end
+
+  def test_cache_hits2
+    input = Input.new('aa')
+    input.memoize!
+    input.exec(LetterA.rule(:top))
+    assert_equal(2, input.cache_hits)
+  end
+
+  def test_cache_hits3
+    input = Input.new('aaa')
+    input.memoize!
+    input.exec(LetterA.rule(:top))
+    assert_equal(0, input.cache_hits)
+  end
+
+  grammar :Addition do
+    rule :additive do
+      all(:number, :plus, label(any(:additive, :number), 'term')) {
+        number.value + term.value
+      }
+    end
+
+    rule :number do
+      all(/[0-9]+/, :space) {
+        strip.to_i
+      }
+    end
+
+    rule :plus do
+      all('+', :space)
+    end
+
+    rule :space do
+      /[ \t]*/
+    end
+  end
+
+  def test_match
+    match = Addition.parse('+', :root => :plus)
+    assert(match)
+    assert(match.matches)
+    assert_equal(2, match.matches.length)
+
+    match = Addition.parse('+ ', :root => :plus)
+    assert(match)
+    assert(match.matches)
+    assert_equal(2, match.matches.length)
+
+    match = Addition.parse('99', :root => :number)
+    assert(match)
+    assert(match.matches)
+    assert_equal(2, match.matches.length)
+
+    match = Addition.parse('99 ', :root => :number)
+    assert(match)
+    assert(match.matches)
+    assert_equal(2, match.matches.length)
+
+    match = Addition.parse('1+2')
+    assert(match)
+    assert(match.matches)
+    assert_equal(3, match.matches.length)
+  end
 end

data/test/label_test.rb

@@ -1,20 +1,11 @@
 require File.expand_path('../helper', __FILE__)
 
 class LabelTest < Test::Unit::TestCase
-
   def test_terminal?
     rule = Label.new
     assert_equal(false, rule.terminal?)
   end
 
-  def test_match
-    rule = Label.new('a', 'label')
-
-    match = rule.match(input('a'))
-    assert(match)
-    assert_equal(:label, match.name)
-  end
-
   def test_to_s
     rule = Label.new('a', 'label')
     assert_equal('label:"a"', rule.to_s)
@@ -22,5 +13,4 @@ class LabelTest < Test::Unit::TestCase
     rule = Label.new(Sequence.new(%w< a b >), 'label')
     assert_equal('label:("a" "b")', rule.to_s)
   end
-
 end

data/test/match_test.rb

@@ -1,56 +1,112 @@
 require File.expand_path('../helper', __FILE__)
 
 class MatchTest < Test::Unit::TestCase
-
-  def test_string
+  def test_string_equality
     match = Match.new('hello')
     assert_equal('hello', match)
-    assert_equal(5, match.length)
-  end
-
-  def test_array_string
-    match1 = Match.new('a')
-    match2 = Match.new('b')
-    match = Match.new([match1, match2])
-    assert_equal('ab', match)
-    assert_equal(2, match.length)
-    assert_equal(2, match.matches.length)
   end
 
-  def test_equality
+  def test_match_equality
     match1 = Match.new('a')
     match2 = Match.new('a')
-    assert(match1 == 'a')
     assert(match1 == match2)
     assert(match2 == match1)
+  end
 
-    match3 = Match.new('b')
-    assert_equal(false, match1 == match3)
-    assert_equal(false, match3 == match1)
+  def test_match_inequality
+    match1 = Match.new('a')
+    match2 = Match.new('b')
+    assert_equal(false, match1 == match2)
+    assert_equal(false, match2 == match1)
   end
 
-  def test_matches
-    match = Double.parse('123')
-    assert(match)
-    assert_equal(3, match.matches.length)
-    assert_equal(3, match.find(:num).length)
+  def test_names
+    a = Rule.new('a')
+    a.name = 'a'
+    b = Rule.new('b')
+    b.name = 'b'
+    c = Rule.new('c')
+    c.name = 'c'
+    s = Rule.new([ a, b, c ])
+    s.name = 's'
+    r = Repeat.new(s, 0, Infinity)
+    r.name = 'r'
+
+    events = [
+      r.id,
+        s.id,
+          a.id, CLOSE, 1,
+          b.id, CLOSE, 1,
+          c.id, CLOSE, 1,
+        CLOSE, 3,
+        s.id,
+          a.id, CLOSE, 1,
+          b.id, CLOSE, 1,
+          c.id, CLOSE, 1,
+        CLOSE, 3,
+        s.id,
+          a.id, CLOSE, 1,
+          b.id, CLOSE, 1,
+          c.id, CLOSE, 1,
+        CLOSE, 3,
+      CLOSE, 9
+    ]
+
+    match = Match.new("abcabcabc", events)
+    assert(match.names)
+    assert_equal([:r], match.names)
+
+    match.matches.each do |m|
+      assert_equal([:s], m.names)
+    end
   end
 
-  def test_match
-    match = Double.parse('456')
-    assert(match)
+  def test_matches
+    a = Rule.new('a')
+    b = Rule.new('b')
+    c = Rule.new('c')
+    s = Rule.new([ a, b, c ])
+    s.name = 's'
+    r = Repeat.new(s, 0, Infinity)
+
+    events = [
+      r.id,
+        s.id,
+          a.id, CLOSE, 1,
+          b.id, CLOSE, 1,
+          c.id, CLOSE, 1,
+        CLOSE, 3,
+        s.id,
+          a.id, CLOSE, 1,
+          b.id, CLOSE, 1,
+          c.id, CLOSE, 1,
+        CLOSE, 3,
+        s.id,
+          a.id, CLOSE, 1,
+          b.id, CLOSE, 1,
+          c.id, CLOSE, 1,
+        CLOSE, 3,
+      CLOSE, 9
+    ]
+
+    match = Match.new("abcabcabc", events)
+    assert(match.matches)
     assert_equal(3, match.matches.length)
 
-    num = match.first(:num)
-    assert(num)
-    assert_equal('4', num)
-    assert_equal(4, num.value)
-  end
+    sub_events = [
+      s.id,
+        a.id, CLOSE, 1,
+        b.id, CLOSE, 1,
+        c.id, CLOSE, 1,
+      CLOSE, 3
+    ]
 
-  def test_matches_deep
-    match = Words.parse('one two three four')
-    assert(match)
-    assert_equal(15, match.find(:alpha).length)
+    match.matches.each do |m|
+      assert_equal(sub_events, m.events)
+      assert_equal(:s, m.name)
+      assert_equal("abc", m)
+      assert(m.matches)
+      assert_equal(3, m.matches.length)
+    end
   end
-
 end

data/test/multibyte_test.rb

@@ -2,7 +2,7 @@ require File.expand_path('../helper', __FILE__)
 
 class MultibyteTest < Test::Unit::TestCase
   Citrus.eval(<<-'CODE')
-  grammar MultibyteTest::Grammar
+  grammar MultibyteTest::Multibyte
     rule string
       "\xFF"
     end
@@ -18,17 +18,17 @@ class MultibyteTest < Test::Unit::TestCase
   CODE
 
   def test_multibyte_string
-    m = Grammar.parse("\xFF", :root => :string)
+    m = Multibyte.parse("\xFF", :root => :string)
     assert(m)
   end
 
   def test_multibyte_regexp
-    m = Grammar.parse("\xFF", :root => :regexp)
+    m = Multibyte.parse("\xFF", :root => :regexp)
     assert(m)
   end
 
   def test_multibyte_character_class
-    m = Grammar.parse("\xFF", :root => :character_class)
+    m = Multibyte.parse("\xFF", :root => :character_class)
     assert(m)
   end
 end