rockit 0.7.1

data/tests/unit/rockit/utest_grammar.rb

@@ -0,0 +1,145 @@
+require 'test/unit'
+
+require 'rockit/grammar'
+include Rockit
+
+class UTestGrammar < Test::Unit::TestCase
+  def test_01_creation
+    g = Rockit::Grammar.new
+    assert_kind_of(Rockit::Grammar, g)
+  end
+
+  TestGrammar1 = Rockit::Grammar.new do
+    rule :A, [["1", :B, :C]]
+    rule :B, [["2", :D]]
+    term :C, "a"
+    term :D, "b"
+  end
+
+  def symbols_as_strings(symbols)
+    symbols.map {|s| s.to_s}.sort
+  end
+
+  def assert_symbols(expected, actual, msg = "")
+    assert_equal(symbols_as_strings(expected), symbols_as_strings(actual), msg)
+  end
+
+  def test_02_simple_grammar
+    assert_kind_of(Rockit::Grammar, TestGrammar1)
+
+    assert_equal(2, TestGrammar1.rules.length)
+    assert_symbols([:A, :B], TestGrammar1.nonterminals)
+    assert_equal(2, TestGrammar1.terms.length)
+    assert_symbols([:C, :D], TestGrammar1.terms.keys)
+
+    assert_kind_of(Rule, ra = TestGrammar1.rules.first)
+    assert_kind_of(Rule, rb = TestGrammar1.rules.last)
+
+    assert_kind_of(Terminal, TestGrammar1.terms[:C])
+    assert_kind_of(Terminal, TestGrammar1.terms[:D])
+
+    assert_equal(:A, ra.name)
+    assert_equal(3, (rarhs = ra.right_hand_side).length)    
+    rarhs1, rarhs2, rarhs3 = rarhs
+    assert_kind_of(StringTerminal, rarhs1)
+    assert_kind_of(NonTerminal, rarhs2)
+    assert_kind_of(NonTerminal, rarhs3)
+    assert_equal("1", rarhs1.string)
+    assert_equal(:B, rarhs2.symbol)
+    assert_equal(:C, rarhs3.symbol)
+
+    assert_equal(:B, rb.name)
+    assert_equal(2, (rbrhs = rb.right_hand_side).length)    
+    rbrhs1, rbrhs2 = rbrhs
+    assert_kind_of(StringTerminal, rbrhs1)
+    assert_kind_of(NonTerminal, rbrhs2)
+    assert_equal("2", rbrhs1.string)
+    assert_equal(:D, rbrhs2.symbol)
+  end
+
+  Arithmetic = Rockit::Grammar.new do
+    #   Additive  <- Multitive '+' Additive
+    #              / Multitive
+    #   Multitive <- Primary '*' Multitive
+    #              / Primary
+    #   Primary   <- '(' Additive ')'
+    #              / Decimal
+    #   Decimal   <- '0' / '1' / '2' / '3' / '4' / '5' / '6' / '7' / '8' / '9'
+
+    start :Additive, [
+      [:Multitive, '+', :Additive],
+      [:Multitive],
+    ]
+    rule :Multitive, [
+      [:Primary, '*', :Multitive],
+      [:Primary]
+    ]
+    rule :Primary, [
+      ['(', :Additive, ')'],
+      [:Decimal]
+    ]
+    term :Decimal, /[0-9]/
+  end
+
+  def test_03_arithmetic_grammar
+    assert_equal(6, Arithmetic.rules.length)
+    assert_symbols([:Additive, :Multitive, :Primary], Arithmetic.nonterminals)
+    assert_equal(1, Arithmetic.terms.length)
+    assert_symbols([:Decimal], Arithmetic.terms.keys)
+    assert_equal(:Additive, Arithmetic.start_symbol)
+    assert_raise(NotImplementedError) {Arithmetic.new_parser.parse("2")}
+
+    ras = Arithmetic.find_rules(:Additive)
+    assert_equal(2, ras.length)
+    ra1, ra2 = ras
+
+    assert_equal(:Additive, ra1.name)
+    assert_equal(3, (ra1rhs = ra1.right_hand_side).length)
+    assert_kind_of(NonTerminal, ra1rhs[0])
+    assert_kind_of(StringTerminal, ra1rhs[1])
+    assert_kind_of(NonTerminal, ra1rhs[2])
+    assert_equal(:Multitive, ra1rhs[0].symbol)
+    assert_equal("+", ra1rhs[1].string)
+    assert_equal(:Additive, ra1rhs[2].symbol)
+
+    assert_equal(:Additive, ra2.name)
+    assert_equal(1, (ra2rhs = ra2.right_hand_side).length)
+    assert_kind_of(NonTerminal, ra2rhs[0])
+    assert_equal(:Multitive, ra2rhs[0].symbol)
+
+    td = Arithmetic.terms[:Decimal]
+    assert_equal(:Decimal, td.name)
+    rdrhs1 = td.right_hand_side
+    assert_equal(1, rdrhs1.length)
+    assert_kind_of(RegexpTerminal, rdrhs1[0])
+  end
+
+  Operators = Rockit::Grammar.new do
+    start :Number, [
+      [plus(:Digit), maybe(/e|E/), maybe("-")],
+      [:Dummy]
+    ]
+    rule :Dummy, [[mult("a"), rep("b", 3, 6)]]
+    term :Digit, /[0-9]/
+  end
+
+  def test_04_operators
+    assert_equal(3, Operators.rules.length)
+    assert_symbols([:Number, :Dummy], Operators.nonterminals)
+    assert_equal(1, Operators.terms.length)
+    assert_symbols([:Digit], Operators.terms.keys)
+    assert_equal(:Number, Operators.start_symbol)
+
+    rn1, rn2 = Operators.find_rules(:Number)
+    assert_equal(:Number, rn1.name)
+
+    assert_equal(3, (rn1rhs = rn1.right_hand_side).length)
+    assert_kind_of(Plus, rn1rhs[0])
+    assert_kind_of(Maybe, rn1rhs[1])
+    assert_kind_of(Maybe, rn1rhs[2])
+
+    assert_kind_of(NonTerminal, rn1rhs[0].symbol)
+    assert_kind_of(RegexpTerminal, rn1rhs[1].symbol)
+    assert_kind_of(StringTerminal, rn1rhs[2].symbol)
+  end
+end

data/tests/unit/rockit/utest_grammar_symbol.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+
+require 'rockit/grammar'
+include Rockit
+
+class UTestGrammarSymbol < Test::Unit::TestCase
+  def test_01_to_grammar_symbol
+    dummy = GrammarSymbol.new
+    assert_equal(dummy, dummy.to_grammar_symbol)
+  end
+end

data/tests/unit/rockit/utest_maybe_operator.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+
+require 'rockit/grammar'
+include Rockit
+
+class UTestRepetitionOperator < Test::Unit::TestCase
+  def test_01
+    m = Maybe.new(:A)
+    assert_kind_of(Maybe, m)
+    assert_kind_of(GrammarSymbol, m)
+  end
+end

data/tests/unit/rockit/utest_regexp_terminal.rb

@@ -0,0 +1,45 @@
+require 'test/unit'
+
+require 'rockit/grammar'
+include Rockit
+
+require 'strscan'
+
+class UTestRegexpTerminal < Test::Unit::TestCase
+  def setup
+    @ret = RegexpTerminal.new(/a/)
+    @retas = RegexpTerminal.new(/a+/)
+  end
+
+  def test_01_smoke
+    assert_kind_of(RegexpTerminal, @ret)
+    assert_kind_of(GrammarSymbol, @ret)
+  end
+
+  def test_02_inspect
+    assert_kind_of(String, @ret.inspect)
+    assert_equal("/a/", @ret.inspect)
+  end
+
+  def test_03_regexp
+    assert_kind_of(Regexp, @ret.regexp)
+    assert_equal(/\s*(a)/, @ret.regexp)
+    assert_equal(/\s*(a+)/, @retas.regexp)
+  end
+
+  def test_04_scan
+    s = StringScanner.new("a")
+    assert_equal("a", @ret.scan(s))
+    assert_equal(1, s.pos)
+
+    s = StringScanner.new("b")
+    assert_equal(nil, @ret.scan(s))
+    assert_equal(0, s.pos)
+  end
+
+  def test_05_dont_scan_over_whitespace
+    s = StringScanner.new("a   b")
+    assert_equal("a", @ret.scan(s))
+    assert_equal(1, s.pos)
+  end
+end

data/tests/unit/rockit/utest_repetition_operators.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+
+require 'rockit/grammar'
+include Rockit
+
+class UTestRepetitionOperator < Test::Unit::TestCase
+  def test_01_creation_of_repetition
+    r = Repetition.new(:A, 2, 10)
+    assert_kind_of(Repetition, r)
+    assert_kind_of(Operator, r)
+    assert_kind_of(GrammarSymbol, r)
+    assert_equal(2, r.min)
+    assert_equal(10, r.max)
+  end
+
+  def test_02_creation_of_mult
+    r = Mult.new(:C)
+    assert_kind_of(Mult, r)
+    assert_kind_of(Repetition, r)
+    assert_kind_of(Operator, r)
+    assert_kind_of(GrammarSymbol, r)
+    assert_equal(0, r.min)
+    assert_equal((1.0/0.0), r.max)
+  end
+
+  def test_03_creation_of_plus
+    r = Plus.new(:C)
+    assert_kind_of(Plus, r)
+    assert_kind_of(Repetition, r)
+    assert_kind_of(Operator, r)
+    assert_kind_of(GrammarSymbol, r)
+    assert_equal(1, r.min)
+    assert_equal((1.0/0.0), r.max)
+  end
+end

data/tests/unit/rockit/utest_rule.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+
+require 'rockit/grammar'
+include Rockit
+
+class UTestRule < Test::Unit::TestCase
+  def test_01_empty_rule
+    r = Rule.new(:r1, [])
+    assert_equal(:r1, r.name)
+    assert_equal([], r.right_hand_side)
+  end
+
+  def test_02
+    r = Rule.new(:r1, [[:a, "B"]])
+    assert_equal(:r1, r.name)
+    assert_equal(2, r.right_hand_side.length)
+    s1, s2 = r.right_hand_side
+    assert_kind_of(NonTerminal, s1)
+    assert_kind_of(StringTerminal, s2)
+    assert_equal(:a, s1.symbol)
+    assert_equal("B", s2.string)
+  end
+end

data/tests/unit/rockit/utest_string_terminal.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+
+require 'rockit/grammar'
+include Rockit
+
+require 'strscan'
+
+class UTestStringTerminal < Test::Unit::TestCase
+  def setup
+    @sta = StringTerminal.new("a")
+    @stp = StringTerminal.new("+")
+  end
+
+  def test_01_smoke
+    assert_kind_of(StringTerminal, @sta)
+    assert_kind_of(GrammarSymbol, @sta)
+    assert_kind_of(StringTerminal, @stp)
+    assert_kind_of(GrammarSymbol, @stp)
+  end
+
+  def test_02_inspect
+    assert_kind_of(String, @sta.inspect)
+    assert_equal("a", @sta.inspect)
+  end
+
+  def test_03_string
+    assert_kind_of(String, @sta.string)
+    assert_equal("a", @sta.string)
+    assert_kind_of(String, @stp.string) 
+    assert_equal("+", @stp.string)
+  end
+
+  def test_04_regexp
+    assert_kind_of(Regexp, @sta.regexp)
+    assert_equal(/\s*(a)/, @sta.regexp)
+    assert_kind_of(Regexp, @stp.regexp)
+    assert_equal(/\s*(\+)/, @stp.regexp)
+    assert_equal("/\\s*(\\+)/", @stp.regexp.inspect)
+  end
+end

data/tests/unit/util/utest_array_alternatives.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+require 'util/array_alternatives'
+
+class UTestArrayAlternatives < Test::Unit::TestCase
+  def test_01_normal_use
+    first, second, third = [1], [2], [3, 4]
+    a = first / second / third
+    alts = a.assemble_alternatives
+    assert_kind_of(Array, alts)
+    assert_equal(3, alts.length)
+    assert_equal(first,  alts[0])
+    assert_equal(second, alts[1])
+    assert_equal(third,  alts[2])
+  end
+
+  def test_02_without_any_alternatives
+    a = [1]
+    alts = a.assemble_alternatives
+    assert_kind_of(Array, alts)
+    assert_equal(1, alts.length)
+    assert_equal(a,  alts[0])
+  end
+end

data/tests/unit/util/utest_enter_leave_visitor.rb

@@ -0,0 +1,89 @@
+require 'test/unit'
+require 'util/enter_leave_visitor'
+
+class TestEnterLeaveVisitor < Test::Unit::TestCase
+  class Mock
+  end
+
+  class SuperMock
+    include EnterLeaveVisitable
+  end
+
+  class ELMock < SuperMock
+  end
+
+  class SuperTELVisitor
+    include EnterLeaveVisitor
+    attr_reader :calls
+    def initialize; @calls = []; end
+
+    def enter_SuperMock(obj); @calls << :enterSuperM; end
+    def visit_SuperMock(obj); @calls << :visitSuperM; end
+    def leave_SuperMock(obj); @calls << :leaveSuperM; end
+  end
+
+  class TELVisitor < SuperTELVisitor
+    def enter_Mock(obj); @calls << :enterM; end
+    def visit_Mock(obj); @calls << :visitM; end
+    def leave_Mock(obj); @calls << :leaveM; end
+
+    def enter_ELMock(obj); @calls << :enterELM; end
+    def visit_ELMock(obj); @calls << :visitELM; end
+    def leave_ELMock(obj); @calls << :leaveELM; end
+
+    def enter_SMock(obj); @calls << :enterSM; end
+    def visit_SMock(obj); @calls << :visitSM; end
+    def leave_SMock(obj); @calls << :leaveSM; end
+  end
+
+  class SMock
+    def initialize(c1, c2)
+      @c1, @c2 = c1, c2
+    end
+    def accept_visitor(v)
+      v.visit_me_then_children self, [@c1, @c2]
+    end
+  end
+
+  class EmptyVisitor
+    include EnterLeaveVisitor
+  end
+
+  def test_01_empty_visitor
+    visitor, m = EmptyVisitor.new, ELMock.new
+    assert_nothing_raised {m.accept_visitor(visitor)}
+  end
+
+  def test_02_visit_std_visitable
+    visitor, m = TELVisitor.new, Mock.new
+    visitor.visit m
+    assert_equal([:enterM, :visitM, :leaveM], visitor.calls)
+  end
+
+  def test_03_visit_enterleavevisitable
+    visitor, m = TELVisitor.new, ELMock.new
+    visitor.visit m
+    assert_equal([:enterELM, :visitELM, :leaveELM], visitor.calls)    
+  end
+
+  def test_04_visit_nested_objects
+    visitor, sm = TELVisitor.new, SMock.new(c1 = ELMock.new, c2 = ELMock.new)
+    sm.accept_visitor(visitor)
+    assert_equal([:enterSM, :visitSM,
+		   :enterELM, :visitELM, :leaveELM,
+		   :enterELM, :visitELM, :leaveELM,
+		   :leaveSM], visitor.calls)
+  end
+
+  def test_05_visit_superclass_visit_method
+    visitor, m1 = SuperTELVisitor.new, ELMock.new
+    m1.accept_visitor(visitor)
+    assert_equal([:enterSuperM, :visitSuperM, :leaveSuperM], visitor.calls)
+  end
+
+  def test_06_visit_our_visitmethod_if_available_both_for_us_and_for_superclass
+    visitor, m1 = TELVisitor.new, ELMock.new
+    m1.accept_visitor(visitor)
+    assert_equal([:enterELM, :visitELM, :leaveELM], visitor.calls)
+  end  
+end

data/tests/unit/util/utest_string_location.rb

@@ -0,0 +1,42 @@
+require 'test/unit'
+
+require 'util/string_location'
+
+class UTestStringLocation < Test::Unit::TestCase
+  def setup
+    @sl = StringLocations.new "a\nb\nc\r\nd"
+  end
+
+  def test_01_creation
+    assert_kind_of(StringLocations, @sl)
+  end
+
+  def test_02_line
+    assert_equal(1, @sl.line(0))
+    assert_equal(1, @sl.line(1))
+    assert_equal(2, @sl.line(2))
+    assert_equal(2, @sl.line(3))
+    assert_equal(3, @sl.line(4))
+    assert_equal(3, @sl.line(5))
+    assert_equal(3, @sl.line(6))
+    assert_equal(4, @sl.line(7))
+  end
+
+  def test_03_column
+    assert_equal(0, @sl.column(0))
+    assert_equal(1, @sl.column(1))
+    assert_equal(0, @sl.column(2))
+    assert_equal(1, @sl.column(3))
+    assert_equal(0, @sl.column(4))
+    assert_equal(1, @sl.column(5))
+    assert_equal(2, @sl.column(6))
+    assert_equal(0, @sl.column(7))
+  end
+
+  def test_04_location
+    assert_equal([1, 0], @sl.location(0))
+    assert_equal([1, 1], @sl.location(1))
+    assert_equal([2, 0], @sl.location(2))
+    assert_equal([2, 1], @sl.location(3))
+  end
+end

data/tests/unit/util/utest_visitor.rb

@@ -0,0 +1,92 @@
+require 'test/unit'
+require 'util/visitor'
+
+class TestVisitor < Test::Unit::TestCase
+  class SuperMock
+    include Visitable
+  end
+
+  class Mock < SuperMock
+    attr_reader :children, :visited
+    def initialize
+      @children = []
+    end
+    def accept_visitor(visitor)
+      @visited = true
+      visitor.visit_me_then_children self, @children
+    end
+  end
+
+  class TVisitor
+    include Visitor
+    attr_reader :count
+    def initialize; @count = 0; end
+    def visit_Mock(obj); @count += 1; end
+  end
+
+  class EmptyVisitor
+    include Visitor
+  end
+
+  # To test whether super class visit method is used if there is no one
+  # for the actual class
+  class SuperMockVisitor
+    include Visitor
+    attr_reader :count
+    def initialize; @count = 0; end
+    def visit_SuperMock(obj); @count += 1; end
+  end
+
+  class MockAndSuperMockVisitor
+    include Visitor
+    attr_reader :countSM, :countM
+    def initialize; @countM = @countSM = 0; end
+    def visit_SuperMock(obj); @countSM += 1; end
+    def visit_Mock(obj); @countM += 1; end
+  end
+
+  def test_01_empty_visitor
+    visitor, m = EmptyVisitor.new, Mock.new
+    assert_nothing_raised {m.accept_visitor(visitor)}
+    assert(m.visited)
+  end
+
+  def test_02_visit
+    visitor, m = TVisitor.new, Mock.new
+    assert_equal(0, visitor.count)
+    visitor.visit(m)
+    assert_equal(1, visitor.count)
+    m.accept_visitor(visitor)
+    assert_equal(2, visitor.count)    
+  end
+
+  def test_03_visit_nested
+    visitor, m1 = TVisitor.new, Mock.new
+    m1.children << (m2 = Mock.new)
+    m2.children << (m3 = Mock.new)
+    m1.accept_visitor(visitor)
+    assert_equal(3, visitor.count)
+    assert(m1.visited)
+    assert(m2.visited)
+    assert(m3.visited)
+  end
+
+  def test_04_visit_superclass_visit_method
+    visitor, m1 = SuperMockVisitor.new, Mock.new
+    m1.accept_visitor(visitor)
+    assert_equal(1, visitor.count)
+  end
+
+  def test_05_visit_our_visitmethod_if_available_both_for_us_and_for_superclass
+    visitor, m1 = MockAndSuperMockVisitor.new, Mock.new
+    m1.accept_visitor(visitor)
+    assert_equal(1, visitor.countM)
+    assert_equal(0, visitor.countSM)
+  end
+
+  def test_06_visit_each
+    visitor, a = TVisitor.new, [Mock.new, Mock.new]
+    visitor.visit_each(a)
+    assert_equal(2, visitor.count)
+  end
+end

data/tests/unit/util/utest_visitor_combinators.rb

@@ -0,0 +1,64 @@
+require 'test/unit'
+
+require 'util/visitor_combinators'
+
+require 'util/visitor'
+
+class UTestVisitorCombinators < Test::Unit::TestCase
+  class Tree
+    attr_reader :children, :visitors
+    def initialize(*children)
+      @children, @visitors = children, []
+    end
+    def accept_visitor(visitor)
+      @visitors << visitor.object_id
+      visitor.visit_me_and_my_children(self, @children)
+    end
+  end
+
+  # Doesn't touch the visited nodes, just saves the fact that they have been
+  # visited
+  class TIdentityVisitor
+    include Visitor
+    attr_reader :visited
+    def initialize
+      @visited = []
+    end
+    def visit_Tree(tree)
+      @visited << tree
+    end
+  end
+
+  def setup
+    @l1, @l2, @l3 = Tree.new, Tree.new, Tree.new
+    @i = Tree.new(@l2, @l3)
+    @r = Tree.new(@l1, @i)
+    @nodes = [@r, @l1, @i, @l2, @l3] 
+  end
+
+  def assert_topdown_leftright_visited(visitor)
+    assert_equal(@r, visitor.visited[0])
+    assert_equal(@l1, visitor.visited[1])
+    assert_equal(@i, visitor.visited[2])
+    assert_equal(@l2, visitor.visited[3])
+    assert_equal(@l3, visitor.visited[4])
+  end
+
+  def test_01_identity_visitor
+    @r.accept_visitor(iv = TIdentityVisitor.new)
+    assert_equal(5, iv.visited.length)
+    assert_topdown_leftright_visited(iv)
+  end
+
+  def test_02_sequence_visitor
+    sv = SequenceVisitor.new(iv1 = TIdentityVisitor.new, iv2 = TIdentityVisitor.new)
+    @r.accept_visitor(sv)
+    assert_topdown_leftright_visited(iv1)
+    assert_topdown_leftright_visited(iv2)
+    # Seems leaf nodes are visited many times by iv1 and iv2 so the assert 
+    # does not hold.
+    # @nodes.each do |n| 
+    #  assert_equal([sv.id, iv1.id, iv2.id], n.visitors)
+    # end
+  end
+end