rltk 2.2.1 → 3.0.0

data/test/tc_cfg.rb

@@ -7,8 +7,8 @@
 # Requires #
 ############
 
-# Standard Library
-require 'test/unit'
+# Gems
+require 'minitest/autorun'
 
 # Ruby Language Toolkit
 require 'rltk/cfg'
@@ -17,7 +17,7 @@ require 'rltk/cfg'
 # Classes and Modules #
 #######################
 
-class CFGTester < Test::Unit::TestCase
+class CFGTester < Minitest::Test
 	def setup
 		@grammar = RLTK::CFG.new
 		
@@ -35,59 +35,74 @@ class CFGTester < Test::Unit::TestCase
 	def test_callback
 		grammar = RLTK::CFG.new
 		
-		first = true
-		grammar.callback do |p, type, num|
-			assert_not_nil(p)
-			assert_equal(type, :'?')
+		call_count = 0
+		grammar.callback do |type, which, p|
+			refute_nil(p)
+			assert_equal(type, :optional)
 			
-			if first
-				assert_equal(num, :first)
-				first = false
-			else
-				assert_equal(num, :second)
+			case call_count
+			when 0 then assert_equal(:empty, which)
+			when 1 then assert_equal(:nonempty, which)
 			end
+			
+			call_count += 1
 		end
 		
 		grammar.production(:a, 'A?') { |a| a }
+		assert_equal(2, call_count)
 		
-		first = true
-		grammar.callback do |p, type, num|
-			assert_not_nil(p)
-			assert_equal(type, :*)
+		call_count = 0
+		grammar.callback do |type, which, p|
+			refute_nil(p)
 			
-			if first
-				assert_equal(num, :first)
-				first = false
-			else
-				assert_equal(num, :second)
+			case call_count
+			when 0
+				assert_equal(:elp, type)
+				assert_equal(:empty, which)
+				
+			when 1
+				assert_equal(:elp, type)
+				assert_equal(:nonempty, which)
+				
+			when 2
+				assert_equal(:nelp, type)
+				assert_equal(:single, which)
+				
+			when 3
+				assert_equal(:nelp, type)
+				assert_equal(:multiple, which)
 			end
+			
+			call_count += 1
 		end
 		
 		grammar.production(:a, 'A*') { |a| a }
+		assert_equal(4, call_count)
 		
-		first = true
-		grammar.callback do |p, type, num|
-			assert_not_nil(p)
-			assert_equal(type, :+)
+		call_count = 0
+		grammar.callback do |type, which, p|
+			refute_nil(p)
+			assert_equal(type, :nelp)
 			
-			if first
-				assert_equal(num, :first)
-				first = false
-			else
-				assert_equal(num, :second)
+			case call_count
+			when 0 then assert_equal(:single, which)
+			when 1 then assert_equal(:multiple, which)
 			end
+			
+			call_count += 1
 		end
 		
 		grammar.production(:a, 'A+') { |a| a }
+		assert_equal(2, call_count)
 	end
 	
 	def test_first_set
 		@grammar.first_set(:s).each do |sym|
-			assert([:A, :B].include?(sym))
+			assert_includes([:A, :B], sym)
 		end
 		
-		assert_equal(@grammar.first_set(:b), [:G])
-		assert_equal(@grammar.first_set(:a), [:G])
+		assert_equal([:G], @grammar.first_set(:b))
+		assert_equal([:G], @grammar.first_set(:a))
 	end
 	
 	def test_follow_set
@@ -103,13 +118,13 @@ class CFGTester < Test::Unit::TestCase
 	end
 	
 	def test_is_nonterminal
-		assert_equal(RLTK::CFG::is_nonterminal?(:lowercase), true)
-		assert_equal(RLTK::CFG::is_nonterminal?(:UPERCASE), false)
+		assert(RLTK::CFG::is_nonterminal?(:lowercase))
+		assert(!RLTK::CFG::is_nonterminal?(:UPERCASE))
 	end
 	
 	def test_is_terminal
-		assert_equal(RLTK::CFG::is_terminal?(:lowercase), false)
-		assert_equal(RLTK::CFG::is_terminal?(:UPERCASE), true)
+		assert(!RLTK::CFG::is_terminal?(:lowercase))
+		assert(RLTK::CFG::is_terminal?(:UPERCASE))
 	end
 	
 	def test_item
@@ -117,25 +132,25 @@ class CFGTester < Test::Unit::TestCase
 		i1 = i0.copy
 		
 		assert_equal(i0, i1)
-		assert_equal(i0.at_end?, false)
-		assert_equal(i0.next_symbol, :b)
+		assert(!i0.at_end?)
+		assert_equal(:b, i0.next_symbol)
 		
 		i0.advance
 		
-		assert_not_equal(i0, i1)
-		assert_equal(i0.at_end?, false)
-		assert_equal(i0.next_symbol, :C)
+		refute_equal(i0, i1)
+		assert(!i0.at_end?)
+		assert_equal(:C, i0.next_symbol)
 		
 		i0.advance
-		assert_equal(i0.at_end?, false)
-		assert_equal(i0.next_symbol, :D)
+		assert(!i0.at_end?)
+		assert_equal(:D, i0.next_symbol)
 		
 		i0.advance
-		assert_equal(i0.at_end?, false)
-		assert_equal(i0.next_symbol, :e)
+		assert(!i0.at_end?)
+		assert_equal(:e, i0.next_symbol)
 		
 		i0.advance
-		assert_equal(i0.at_end?, true)
+		assert(i0.at_end?)
 		assert_nil(i0.next_symbol)
 	end
 	
@@ -144,6 +159,6 @@ class CFGTester < Test::Unit::TestCase
 		p1 = p0.copy
 		
 		assert_equal(p0, p1)
-		assert_equal(p0.last_terminal, :D)
+		assert_equal(:D, p0.last_terminal)
 	end
 end

data/test/tc_lexer.rb

@@ -7,8 +7,8 @@
 # Requires #
 ############
 
-# Standard Library
-require 'test/unit'
+# Gems
+require 'minitest/autorun'
 
 # Ruby Language Toolkit
 require 'rltk/token'
@@ -20,21 +20,21 @@ require 'rltk/lexers/ebnf'
 # Classes and Modules #
 #######################
 
-class LexerTester < Test::Unit::TestCase
+class LexerTester < Minitest::Test
 	class ABLongest < RLTK::Lexer
-		rule(/a+/)	{ :APLUS }
-		rule(/b+/)	{ :BPLUS }
+		rule(/a+/)   { :APLUS }
+		rule(/b+/)   { :BPLUS }
 	
-		rule(/a+b+/)	{ :APLUSBPLUS }
+		rule(/a+b+/) { :APLUSBPLUS }
 	end
 
 	class ABFirst < RLTK::Lexer
 		match_first
 	
-		rule(/a+/)	{ :APLUS }
-		rule(/b+/)	{ :BPLUS }
+		rule(/a+/)   { :APLUS }
+		rule(/b+/)   { :BPLUS }
 	
-		rule(/a+b+/)	{ :APLUSBPLUS }
+		rule(/a+b+/) { :APLUSBPLUS }
 	end
 
 	class ENVLexer < RLTK::Lexer
@@ -53,21 +53,21 @@ class LexerTester < Test::Unit::TestCase
 	end
 
 	class FlagLexer < RLTK::Lexer
-		rule(/a/)		{ set_flag(:a); :A }
+		rule(/a/)	 { set_flag(:a); :A }
 		rule(/\s/)
 	
-		rule(/b/, :default, [:a])	{ set_flag(:b); :B }
-		rule(/c/, :default, [:a, :b])	{ :C }
+		rule(/b/, :default, [:a])     { set_flag(:b); :B }
+		rule(/c/, :default, [:a, :b]) { :C }
 	end
 
 	class StateLexer < RLTK::Lexer
-		rule(/a/)		{ :A }
+		rule(/a/)    { :A }
 		rule(/\s/)
 	
-		rule(/\(\*/)	{ push_state(:comment) }
+		rule(/\(\*/) { push_state(:comment) }
 	
-		rule(/\(\*/, :comment)	{ push_state(:comment) }
-		rule(/\*\)/, :comment)	{ pop_state }
+		rule(/\(\*/, :comment) { push_state(:comment) }
+		rule(/\*\)/, :comment) { pop_state }
 		rule(/./,    :comment)
 	end
 
@@ -76,19 +76,18 @@ class LexerTester < Test::Unit::TestCase
 	end
 	
 	def test_calc
-		expected =
-			[
-				RLTK::Token.new(:NUM, 1),
-				
-				RLTK::Token.new(:PLS),
-				RLTK::Token.new(:SUB),
-				RLTK::Token.new(:MUL),
-				RLTK::Token.new(:DIV),
-				
-				RLTK::Token.new(:LPAREN),
-				RLTK::Token.new(:RPAREN),
-				RLTK::Token.new(:EOS)
-			]
+		expected = [
+			RLTK::Token.new(:NUM, 1),
+			
+			RLTK::Token.new(:PLS),
+			RLTK::Token.new(:SUB),
+			RLTK::Token.new(:MUL),
+			RLTK::Token.new(:DIV),
+			
+			RLTK::Token.new(:LPAREN),
+			RLTK::Token.new(:RPAREN),
+			RLTK::Token.new(:EOS)
+		]
 		
 		actual = RLTK::Lexers::Calculator.lex('1 + - * / ( )')
 		
@@ -96,16 +95,15 @@ class LexerTester < Test::Unit::TestCase
 	end
 	
 	def test_ebnf
-		expected =
-			[
-				RLTK::Token.new(:NONTERM, :aaa),
-				RLTK::Token.new(:TERM, :BBB),
-				
-				RLTK::Token.new(:*),
-				RLTK::Token.new(:+),
-				RLTK::Token.new(:'?'),
-				RLTK::Token.new(:EOS)
-			]
+		expected = [
+			RLTK::Token.new(:NONTERM, :aaa),
+			RLTK::Token.new(:TERM, :BBB),
+			
+			RLTK::Token.new(:STAR),
+			RLTK::Token.new(:PLUS),
+			RLTK::Token.new(:QUESTION),
+			RLTK::Token.new(:EOS)
+		]
 		
 		actual = RLTK::Lexers::EBNF.lex('aaa BBB * + ?')
 		
@@ -113,13 +111,12 @@ class LexerTester < Test::Unit::TestCase
 	end
 	
 	def test_environment
-		expected =
-			[
-				RLTK::Token.new(:A, 0),
-				RLTK::Token.new(:A, 1),
-				RLTK::Token.new(:A, 2),
-				RLTK::Token.new(:EOS)
-			]
+		expected = [
+			RLTK::Token.new(:A, 0),
+			RLTK::Token.new(:A, 1),
+			RLTK::Token.new(:A, 2),
+			RLTK::Token.new(:EOS)
+		]
 		
 		actual = ENVLexer.lex('aaa')
 		
@@ -129,24 +126,22 @@ class LexerTester < Test::Unit::TestCase
 		
 		assert_equal(expected, lexer.lex('aaa'))
 		
-		expected =
-			[
-				RLTK::Token.new(:A, 3),
-				RLTK::Token.new(:A, 4),
-				RLTK::Token.new(:A, 5),
-				RLTK::Token.new(:EOS)
-			]
+		expected = [
+			RLTK::Token.new(:A, 3),
+			RLTK::Token.new(:A, 4),
+			RLTK::Token.new(:A, 5),
+			RLTK::Token.new(:EOS)
+		]
 		
 		assert_equal(expected, lexer.lex('aaa'))
 	end
 	
 	def test_first_match
-		expected =
-			[
-				RLTK::Token.new(:APLUS),
-				RLTK::Token.new(:BPLUS),
-				RLTK::Token.new(:EOS)
-			]
+		expected = [
+			RLTK::Token.new(:APLUS),
+			RLTK::Token.new(:BPLUS),
+			RLTK::Token.new(:EOS)
+		]
 		
 		actual = ABFirst.lex('aaabbb')
 		
@@ -155,49 +150,43 @@ class LexerTester < Test::Unit::TestCase
 	
 	def test_flags
 		
-		assert_raise(RLTK::LexingError) { FlagLexer.lex('b') }
-		assert_raise(RLTK::LexingError) { FlagLexer.lex('ac') }
+		assert_raises(RLTK::LexingError) { FlagLexer.lex('b') }
+		assert_raises(RLTK::LexingError) { FlagLexer.lex('ac') }
 		
-		expected =
-			[
-				RLTK::Token.new(:A),
-				RLTK::Token.new(:B),
-				RLTK::Token.new(:C),
-				RLTK::Token.new(:EOS)
-			]
+		expected = [
+			RLTK::Token.new(:A),
+			RLTK::Token.new(:B),
+			RLTK::Token.new(:C),
+			RLTK::Token.new(:EOS)
+		]
 		
 		actual = FlagLexer.lex('abc')
 		assert_equal(expected, actual)
 		
-		expected =
-			[
-				RLTK::Token.new(:A),
-				RLTK::Token.new(:B),
-				RLTK::Token.new(:C),
-				RLTK::Token.new(:A),
-				RLTK::Token.new(:B),
-				RLTK::Token.new(:C),
-				RLTK::Token.new(:EOS)
-			]
+		expected = [
+			RLTK::Token.new(:A),
+			RLTK::Token.new(:B),
+			RLTK::Token.new(:C),
+			RLTK::Token.new(:A),
+			RLTK::Token.new(:B),
+			RLTK::Token.new(:C),
+			RLTK::Token.new(:EOS)
+		]
 		
 		actual = FlagLexer.lex('abcabc')
 		assert_equal(expected, actual)
 	end
 	
 	def test_lex
-		assert_raise(RLTK::LexingError) { ABFirst.lex('aaabbbCCC') }
-		assert_raise(RLTK::LexingError) { ABLongest.lex('aaabbbCCC') }
-		
-		assert_nothing_raised(RLTK::LexingError) { ABFirst.lex('aaabbb') }
-		assert_nothing_raised(RLTK::LexingError) { ABLongest.lex('aaabbb') }
+		assert_raises(RLTK::LexingError) { ABFirst.lex('aaabbbCCC') }
+		assert_raises(RLTK::LexingError) { ABLongest.lex('aaabbbCCC') }
 	end
 	
 	def test_longest_match
-		expected =
-			[
-				RLTK::Token.new(:APLUSBPLUS),
-				RLTK::Token.new(:EOS)
-			]
+		expected = [
+			RLTK::Token.new(:APLUSBPLUS),
+			RLTK::Token.new(:EOS)
+		]
 		
 		actual = ABLongest.lex('aaabbb')
 		
@@ -205,19 +194,18 @@ class LexerTester < Test::Unit::TestCase
 	end
 	
 	def test_match_data
-		expected	= [RLTK::Token.new(:FOO, ['', 'ccc']), RLTK::Token.new(:EOS)]
-		actual	= MatchDataLexer.lex('accc')
+		expected = [RLTK::Token.new(:FOO, ['', 'ccc']), RLTK::Token.new(:EOS)]
+		actual   = MatchDataLexer.lex('accc')
 		
 		assert_equal(expected, actual)
 	end
 	
 	def test_state
-		expected =
-			[
-				RLTK::Token.new(:A),
-				RLTK::Token.new(:A),
-				RLTK::Token.new(:EOS)
-			]
+		expected = [
+			RLTK::Token.new(:A),
+			RLTK::Token.new(:A),
+			RLTK::Token.new(:EOS)
+		]
 		
 		actual = StateLexer.lex('a (* bbb *) a')
 		assert_equal(expected, actual)