rltk 2.2.1 → 3.0.0

data/test/tc_parser.rb

@@ -8,9 +8,11 @@
 ############
 
 # Standard Library
-require 'test/unit'
 require 'tmpdir'
 
+# Gems
+require 'minitest/autorun'
+
 # Ruby Language Toolkit
 require 'rltk/lexer'
 require 'rltk/parser'
@@ -23,7 +25,7 @@ require 'rltk/parsers/postfix_calc'
 # Classes and Modules #
 #######################
 
-class ParserTester < Test::Unit::TestCase
+class ParserTester < Minitest::Test
 	class ABLexer < RLTK::Lexer
 		rule(/a/) { [:A, 1] }
 		rule(/b/) { [:B, 2] }
@@ -39,6 +41,10 @@ class ParserTester < Test::Unit::TestCase
 		rule(/\s/)
 	end
 	
+	class UnderscoreLexer < RLTK::Lexer
+		rule(/\w/) { |t| [:A_TOKEN, t] }
+	end
+	
 	class APlusBParser < RLTK::Parser
 		production(:a, 'A+ B') { |a, _| a.length }
 		
@@ -71,7 +77,7 @@ class ParserTester < Test::Unit::TestCase
 	end
 	
 	class ArrayCalc < RLTK::Parser
-		array_args
+		dat :array
 		
 		production(:e) do
 			clause('NUM') { |v| v[0] }
@@ -85,16 +91,56 @@ class ParserTester < Test::Unit::TestCase
 		finalize
 	end
 	
+	# This grammar is purposefully ambiguous.  This should not be equivalent
+	# to the grammar produced with `e -> A B? B?`, due to greedy Kleene
+	# operators.
+	class AmbiguousParseStackParser < RLTK::Parser
+		production(:s, 'e*') { |e| e }
+		
+		production(:e, 'A b_question b_question') { |a, b0, b1| [a, b0, b1] }
+		
+		production(:b_question) do
+			clause('')	{ | | nil }
+			clause('B')	{ |b|   b }
+		end
+		
+		finalize
+	end
+	
 	class EmptyListParser0 < RLTK::Parser
-		empty_list('list', :A, :COMMA)
+		list('list', :A, :COMMA)
 		
 		finalize
 	end
 	
 	class EmptyListParser1 < RLTK::Parser
-		array_args
+		dat :array
+		
+		list('list', ['A', 'B', 'C D'], :COMMA)
+		
+		finalize
+	end
+	
+	class GreedTestParser0 < RLTK::Parser
+		production(:e, 'A? A') { |a0, a1| [a0, a1] }
 		
-		empty_list('list', ['A', 'B', 'C D'], :COMMA)
+		finalize
+	end
+	
+	class GreedTestParser1 < RLTK::Parser
+		production(:e, 'A? A?') { |a0, a1| [a0, a1] }
+		
+		finalize
+	end
+	
+	class GreedTestParser2 < RLTK::Parser
+		production(:e, 'A* A') { |a0, a1| [a0, a1] }
+		
+		finalize
+	end
+	
+	class GreedTestParser3 < RLTK::Parser
+		production(:e, 'A+ A') { |a0, a1| [a0, a1] }
 		
 		finalize
 	end
@@ -108,7 +154,7 @@ class ParserTester < Test::Unit::TestCase
 	class NonEmptyListParser1 < RLTK::Parser
 		nonempty_list('list', [:A, :B], :COMMA)
 		
-		finalize
+		finalize explain: 'nelp1.tbl'
 	end
 	
 	class NonEmptyListParser2 < RLTK::Parser
@@ -123,6 +169,18 @@ class ParserTester < Test::Unit::TestCase
 		finalize
 	end
 	
+	class NonEmptyListParser4 < RLTK::Parser
+		nonempty_list('list', :A)
+		
+		finalize
+	end
+	
+	class NonEmptyListParser5 < RLTK::Parser
+		nonempty_list('list', :A, 'B C?')
+		
+		finalize
+	end
+	
 	class DummyError1 < StandardError; end
 	class DummyError2 < StandardError; end
 	
@@ -166,7 +224,13 @@ class ParserTester < Test::Unit::TestCase
 	
 		finalize
 	end
-
+	
+	class UnderscoreParser < RLTK::Parser
+		production(:s, 'A_TOKEN+') { |o| o }
+		
+		finalize
+	end
+	
 	class RotatingCalc < RLTK::Parser
 		production(:e) do
 			clause('NUM') {|n| n}
@@ -195,11 +259,24 @@ class ParserTester < Test::Unit::TestCase
 		finalize
 	end
 	
+	class SelectionParser < RLTK::Parser
+		production(:s, 'A+ .B+') { |bs| bs.inject &:+ }
+		
+		finalize
+	end
+	
 	def test_ambiguous_grammar
 		actual = AmbiguousParser.parse(RLTK::Lexers::Calculator.lex('1 + 2 * 3'), {:accept => :all})
 		assert_equal([7, 9], actual.sort)
 	end
 	
+	# This test is to ensure that objects placed on the output stack are
+	# cloned when we split the parse stack.  This was posted as Issue #17 on
+	# Github.
+	def test_ambiguous_parse_stack
+		assert_equal(1, AmbiguousParseStackParser.parse(ABLexer.lex('ab')).length)
+	end
+	
 	def test_array_args
 		actual = ArrayCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 2'))
 		assert_equal(3, actual)
@@ -216,7 +293,8 @@ class ParserTester < Test::Unit::TestCase
 		# APlusBParser #
 		################
 		
-		assert_raise(RLTK::NotInLanguage) { APlusBParser.parse(ABLexer.lex('b')) }
+		assert_raises(RLTK::NotInLanguage) { APlusBParser.parse(ABLexer.lex('b')) }
+		
 		assert_equal(1, APlusBParser.parse(ABLexer.lex('ab')))
 		assert_equal(2, APlusBParser.parse(ABLexer.lex('aab')))
 		assert_equal(3, APlusBParser.parse(ABLexer.lex('aaab')))
@@ -226,9 +304,9 @@ class ParserTester < Test::Unit::TestCase
 		# AQuestionBParser #
 		####################
 		
-		assert_raise(RLTK::NotInLanguage) { AQuestionBParser.parse(ABLexer.lex('aab')) }
+		assert_raises(RLTK::NotInLanguage) { AQuestionBParser.parse(ABLexer.lex('aab')) }
 		assert_nil(AQuestionBParser.parse(ABLexer.lex('b')))
-		assert_not_nil(AQuestionBParser.parse(ABLexer.lex('ab')))
+		refute_nil(AQuestionBParser.parse(ABLexer.lex('ab')))
 		
 		################
 		# AStarBParser #
@@ -246,16 +324,75 @@ class ParserTester < Test::Unit::TestCase
 		# EmptyListParser0 #
 		####################
 		
-		expected	= []
-		actual	= EmptyListParser0.parse(AlphaLexer.lex(''))
+		expected = []
+		actual   = EmptyListParser0.parse(AlphaLexer.lex(''))
 		assert_equal(expected, actual)
 		
 		####################
 		# EmptyListParser1 #
 		####################
 		
-		expected	= ['a', 'b', ['c', 'd']]
-		actual	= EmptyListParser1.parse(AlphaLexer.lex('a, b, c d'))
+		expected = ['a', 'b', ['c', 'd']]
+		actual   = EmptyListParser1.parse(AlphaLexer.lex('a, b, c d'))
+		assert_equal(expected, actual)
+	end
+	
+	def test_greed
+		
+		####################
+		# GreedTestParser0 #
+		####################
+		
+		expected = [nil, 'a']
+		actual   = GreedTestParser0.parse(AlphaLexer.lex('a'))
+		assert_equal(expected, actual)
+		
+		expected = ['a', 'a']
+		actual   = GreedTestParser0.parse(AlphaLexer.lex('a a'))
+		assert_equal(expected, actual)
+		
+		####################
+		# GreedTestParser1 #
+		####################
+		
+		expected = [nil, nil]
+		actual   = GreedTestParser1.parse(AlphaLexer.lex(''))
+		assert_equal(expected, actual)
+		
+#		expected = ['a', nil]
+#		actual   = GreedTestParser1.parse(AlphaLexer.lex('a'))
+#		assert_equal(expected, actual)
+		
+		expected = ['a', 'a']
+		actual   = GreedTestParser1.parse(AlphaLexer.lex('a a'))
+		assert_equal(expected, actual)
+		
+		####################
+		# GreedTestParser2 #
+		####################
+		
+		expected = [[], 'a']
+		actual   = GreedTestParser2.parse(AlphaLexer.lex('a'))
+		assert_equal(expected, actual)
+		
+		expected = [['a'], 'a']
+		actual   = GreedTestParser2.parse(AlphaLexer.lex('a a'))
+		assert_equal(expected, actual)
+		
+		expected = [['a', 'a'], 'a']
+		actual   = GreedTestParser2.parse(AlphaLexer.lex('a a a'))
+		assert_equal(expected, actual)
+		
+		####################
+		# GreedTestParser3 #
+		####################
+		
+		expected = [['a'], 'a']
+		actual   = GreedTestParser3.parse(AlphaLexer.lex('a a'))
+		assert_equal(expected, actual)
+		
+		expected = [['a', 'a'], 'a']
+		actual   = GreedTestParser3.parse(AlphaLexer.lex('a a a'))
 		assert_equal(expected, actual)
 	end
 	
@@ -287,7 +424,7 @@ class ParserTester < Test::Unit::TestCase
 		test_string += "third line;\n"
 		test_string += "fourth line\n"
 		
-		assert_raise(RLTK::HandledError) { ErrorLine.parse(ELLexer.lex(test_string)) }
+		assert_raises(RLTK::HandledError) { ErrorLine.parse(ELLexer.lex(test_string)) }
 		
 		begin
 			ErrorLine.parse(ELLexer.lex(test_string))
@@ -328,11 +465,11 @@ class ParserTester < Test::Unit::TestCase
 		actual = RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('(1 + 2) * 3'))
 		assert_equal(9, actual)
 		
-		assert_raise(RLTK::NotInLanguage) { RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('1 2 + 3 *')) }
+		assert_raises(RLTK::NotInLanguage) { RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('1 2 + 3 *')) }
 	end
 	
 	def test_input
-		assert_raise(RLTK::BadToken) { RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::EBNF.lex('A B C')) }
+		assert_raises(RLTK::BadToken) { RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::EBNF.lex('A B C')) }
 	end
 	
 	def test_nonempty_list
@@ -340,72 +477,91 @@ class ParserTester < Test::Unit::TestCase
 		# NonEmptyListParser0 #
 		#######################
 		
-		expected	= ['a']
-		actual	= NonEmptyListParser0.parse(AlphaLexer.lex('a'))
+		expected = ['a']
+		actual   = NonEmptyListParser0.parse(AlphaLexer.lex('a'))
 		assert_equal(expected, actual)
 		
-		expected	= ['a', 'a']
-		actual	= NonEmptyListParser0.parse(AlphaLexer.lex('a, a'))
+		expected = ['a', 'a']
+		actual   = NonEmptyListParser0.parse(AlphaLexer.lex('a, a'))
 		assert_equal(expected, actual)
 		
-		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(''))   }
-		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(','))  }
-		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex('aa')) }
-		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex('a,')) }
-		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(',a')) }
+		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(''))   }
+		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(','))  }
+		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex('aa')) }
+		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex('a,')) }
+		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(',a')) }
 		
 		#######################
 		# NonEmptyListParser1 #
 		#######################
 		
-		expected	= ['a']
-		actual	= NonEmptyListParser1.parse(AlphaLexer.lex('a'))
+		expected = ['a']
+		actual   = NonEmptyListParser1.parse(AlphaLexer.lex('a'))
 		assert_equal(expected, actual)
 		
-		expected	= ['b']
-		actual	= NonEmptyListParser1.parse(AlphaLexer.lex('b'))
+		expected = ['b']
+		actual   = NonEmptyListParser1.parse(AlphaLexer.lex('b'))
 		assert_equal(expected, actual)
 		
-		expected	= ['a', 'b', 'a', 'b']
-		actual	= NonEmptyListParser1.parse(AlphaLexer.lex('a, b, a, b'))
+		expected = ['a', 'b', 'a', 'b']
+		actual   = NonEmptyListParser1.parse(AlphaLexer.lex('a, b, a, b'))
 		assert_equal(expected, actual)
 		
-		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser1.parse(AlphaLexer.lex('a b')) }
+		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser1.parse(AlphaLexer.lex('a b')) }
+		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser1.parse(AlphaLexer.lex('a, ')) }
 		
 		#######################
 		# NonEmptyListParser2 #
 		#######################
 		
-		expected	= ['a']
-		actual	= NonEmptyListParser2.parse(AlphaLexer.lex('a'))
+		expected = ['a']
+		actual   = NonEmptyListParser2.parse(AlphaLexer.lex('a'))
 		assert_equal(expected, actual)
 		
-		expected	= ['b']
-		actual	= NonEmptyListParser2.parse(AlphaLexer.lex('b'))
+		expected = ['b']
+		actual   = NonEmptyListParser2.parse(AlphaLexer.lex('b'))
 		assert_equal(expected, actual)
 		
-		expected	= [['c', 'd']]
-		actual	= NonEmptyListParser2.parse(AlphaLexer.lex('c d'))
+		expected = [['c', 'd']]
+		actual   = NonEmptyListParser2.parse(AlphaLexer.lex('c d'))
 		assert_equal(expected, actual)
 		
-		expected	= [['c', 'd'], ['c', 'd']]
-		actual	= NonEmptyListParser2.parse(AlphaLexer.lex('c d, c d'))
+		expected = [['c', 'd'], ['c', 'd']]
+		actual   = NonEmptyListParser2.parse(AlphaLexer.lex('c d, c d'))
 		assert_equal(expected, actual)
 		
-		expected	= ['a', 'b', ['c', 'd']]
-		actual	= NonEmptyListParser2.parse(AlphaLexer.lex('a, b, c d'))
+		expected = ['a', 'b', ['c', 'd']]
+		actual   = NonEmptyListParser2.parse(AlphaLexer.lex('a, b, c d'))
 		assert_equal(expected, actual)
 		
-		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser2.parse(AlphaLexer.lex('c')) }
-		assert_raise(RLTK::NotInLanguage) { NonEmptyListParser2.parse(AlphaLexer.lex('d')) }
+		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser2.parse(AlphaLexer.lex('c')) }
+		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser2.parse(AlphaLexer.lex('d')) }
 		
 		#######################
 		# NonEmptyListParser3 #
 		#######################
 		
-		expected	= [['a'], ['a', 'a'], ['a', 'a', 'a']]
-		actual	= NonEmptyListParser3.parse(AlphaLexer.lex('a, aa, aaa'))
+		expected = [['a'], ['a', 'a'], ['a', 'a', 'a']]
+		actual   = NonEmptyListParser3.parse(AlphaLexer.lex('a, aa, aaa'))
 		assert_equal(expected, actual)
+		
+		#######################
+		# NonEmptyListParser4 #
+		#######################
+		
+		expected = ['a', 'a', 'a']
+		actual   = NonEmptyListParser4.parse(AlphaLexer.lex('a a a'))
+		assert_equal(expected, actual)
+		
+		#######################
+		# NonEmptyListParser5 #
+		#######################
+		
+		expected = ['a', 'a', 'a']
+		actual   = NonEmptyListParser5.parse(AlphaLexer.lex('a b a b c a'))
+		assert_equal(expected, actual)
+		
+		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser5.parse(AlphaLexer.lex('a b b a')) }
 	end
 	
 	def test_postfix_calc
@@ -418,7 +574,7 @@ class ParserTester < Test::Unit::TestCase
 		actual = RLTK::Parsers::PostfixCalc.parse(RLTK::Lexers::Calculator.lex('1 2 + 3 *'))
 		assert_equal(9, actual)
 		
-		assert_raise(RLTK::NotInLanguage) { RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('* + 1 2 3')) }
+		assert_raises(RLTK::NotInLanguage) { RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('* + 1 2 3')) }
 	end
 	
 	def test_prefix_calc
@@ -431,16 +587,32 @@ class ParserTester < Test::Unit::TestCase
 		actual = RLTK::Parsers::PrefixCalc.parse(RLTK::Lexers::Calculator.lex('* + 1 2 3'))
 		assert_equal(9, actual)
 		
-		assert_raise(RLTK::NotInLanguage) { RLTK::Parsers::PrefixCalc.parse(RLTK::Lexers::Calculator.lex('1 + 2 * 3')) }
+		assert_raises(RLTK::NotInLanguage) { RLTK::Parsers::PrefixCalc.parse(RLTK::Lexers::Calculator.lex('1 + 2 * 3')) }
+	end
+	
+	def test_selection_parser
+		actual   = SelectionParser.parse(ABLexer.lex('aaabbb'))
+		expected = 6
+		
+		assert_equal(expected, actual)
+	end
+	
+	def test_underscore_tokens
+		actual   = UnderscoreParser.parse(UnderscoreLexer.lex('abc')).join
+		expected = 'abc'
+		
+		assert_equal(expected, actual)
 	end
 	
 	def test_use
 		tmpfile = File.join(Dir.tmpdir, 'usetest')
 		
+		FileUtils.rm(tmpfile) if File.exist?(tmpfile)
+		
 		parser0 = Class.new(RLTK::Parser) do
 			production(:a, 'A+') { |a| a.length }
 			
-			finalize :use => tmpfile
+			finalize use: tmpfile
 		end
 		
 		result0 = parser0.parse(ABLexer.lex('a'))
@@ -450,7 +622,7 @@ class ParserTester < Test::Unit::TestCase
 		parser1 = Class.new(RLTK::Parser) do
 			production(:a, 'A+') { |a| a.length }
 			
-			finalize :use => tmpfile
+			finalize use: tmpfile
 		end
 		
 		result1 = parser1.parse(ABLexer.lex('a'))

data/test/tc_token.rb

@@ -7,8 +7,8 @@
 # Requires #
 ############
 
-# Standard Library
-require 'test/unit'
+# Gems
+require 'minitest/autorun'
 
 # Ruby Language Toolkit
 require 'rltk/token'
@@ -17,7 +17,7 @@ require 'rltk/token'
 # Classes and Modules #
 #######################
 
-class TokenTester < Test::Unit::TestCase
+class TokenTester < Minitest::Test
 	def test_equal
 		t0 = RLTK::Token.new(:FOO, 0)
 		t1 = RLTK::Token.new(:FOO, 0)
@@ -27,8 +27,8 @@ class TokenTester < Test::Unit::TestCase
 		
 		assert_equal(t0, t1)
 		
-		assert_not_equal(t0, t2)
-		assert_not_equal(t0, t3)
-		assert_not_equal(t0, t4)
+		refute_equal(t0, t2)
+		refute_equal(t0, t3)
+		refute_equal(t0, t4)
 	end
 end

data/test/ts_rltk.rb

@@ -8,21 +8,17 @@
 # Requires #
 ############
 
-if RUBY_VERSION[0..2] == '1.9'
-	begin
-		require 'simplecov'
-		SimpleCov.start do
-			add_filter 'tc_*'
-			add_filter 'generated*'
-		end
-		
-	rescue LoadError
-		puts 'SimpleCov not installed.  Continuing without it.'
+# Filigree
+require 'filigree/request_file'
+
+request_file('simplecov', 'SimpleCov is not installed.') do
+	SimpleCov.start do
+		add_filter 'tc_*'
+		add_filter 'generated*'
 	end
 end
 
-# Rubygems
-require 'rubygems'
+# Gems
 require 'ffi'
 
 # Ruby Language Toolkit
@@ -35,9 +31,8 @@ require 'tc_cfg'
 require 'tc_lexer'
 require 'tc_parser'
 
-require 'util/ts_util'
-
 begin
+	# Check to make sure the target LLVM library is present.
 	class Tester
 		extend FFI::Library
 		
@@ -46,5 +41,7 @@ begin
 	
 	# The test suite for the LLVM bindings
 	require 'cg/ts_cg'
-rescue
+	
+rescue LoadError
+	puts "Unable to test LLVM bindings.  Library LLVM-#{RLTK::LLVM_TARGET_VERSION} not found."
 end