rltk 1.1.0

data/test/tc_parser.rb

@@ -0,0 +1,275 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2011/04/06
+# Description:	This file contains unit tests for the RLTK::Parser class.
+
+############
+# Requires #
+############
+
+# Standard Library
+require 'pp'
+require 'test/unit'
+
+# Ruby Language Toolkit
+require 'rltk/lexer'
+require 'rltk/parser'
+require 'rltk/lexers/calculator'
+require 'rltk/parsers/prefix_calc'
+require 'rltk/parsers/infix_calc'
+require 'rltk/parsers/postfix_calc'
+
+#######################
+# Classes and Modules #
+#######################
+
+class ABLexer < RLTK::Lexer
+	rule(/a/) { [:A, 1] }
+	rule(/b/) { [:B, 2] }
+	
+	rule(/\s/)
+end
+
+class APlusBParser < RLTK::Parser
+	production(:a, 'A+ B') { |a, _| a.length }
+	
+	finalize
+end
+
+class AQuestionBParser < RLTK::Parser
+	production(:a, 'A? B') { |a, _| a }
+	
+	finalize
+end
+
+class AStarBParser < RLTK::Parser
+	production(:a, 'A* B') { |a, _| a.length }
+	
+	finalize
+end
+
+class AmbiguousParser < RLTK::Parser
+	production(:e) do
+		clause('NUM') {|n| n}
+		
+		clause('e PLS e') { |e0, _, e1| e0 + e1 }
+		clause('e SUB e') { |e0, _, e1| e0 - e1 }
+		clause('e MUL e') { |e0, _, e1| e0 * e1 }
+		clause('e DIV e') { |e0, _, e1| e0 / e1 }
+	end
+	
+	finalize
+end
+
+class ArrayCalc < RLTK::Parser
+	array_args
+	
+	production(:e) do
+		clause('NUM') { |v| v[0] }
+		
+		clause('PLS e e') { |v| v[1] + v[2] }
+		clause('SUB e e') { |v| v[1] - v[2] }
+		clause('MUL e e') { |v| v[1] * v[2] }
+		clause('DIV e e') { |v| v[1] / v[2] }
+	end
+	
+	finalize
+end
+
+class DummyError1 < Exception; end
+class DummyError2 < Exception; end
+
+class ErrorCalc < RLTK::Parser
+	production(:e) do
+		clause('NUM') {|n| n}
+		
+		clause('e PLS e') { |e0, _, e1| e0 + e1 }
+		clause('e SUB e') { |e0, _, e1| e0 - e1 }
+		clause('e MUL e') { |e0, _, e1| e0 * e1 }
+		clause('e DIV e') { |e0, _, e1| e0 / e1 }
+		
+		clause('e PLS ERROR') { |_, _, _| raise DummyError1 }
+		clause('e SUB ERROR') { |_, _, _| raise DummyError2 }
+	end
+	
+	finalize
+end
+
+class ELLexer < RLTK::Lexer
+	rule(/\n/)	{ :NEWLINE }
+	rule(/;/)		{ :SEMI    }
+	
+	rule(/\s/)
+	
+	rule(/[A-Za-z]+/)	{ |t| [:WORD, t] }
+end
+
+class ErrorLine < RLTK::Parser
+	
+	production(:s, 'line*') { |l| l }
+	
+	production(:line) do
+		clause('NEWLINE') { |_| nil }
+		
+		clause('WORD+ SEMI NEWLINE')	{ |w, _, _| w }
+		clause('WORD+ ERROR NEWLINE')	{ |w, e, _| error(pos(1).line_number); w }
+	end
+	
+	finalize
+end
+
+class RotatingCalc < RLTK::Parser
+	production(:e) do
+		clause('NUM') {|n| n}
+		
+		clause('PLS e e') { |_, e0, e1| e0.send(get_op(:+), e1) }
+		clause('SUB e e') { |_, e0, e1| e0.send(get_op(:-), e1) }
+		clause('MUL e e') { |_, e0, e1| e0.send(get_op(:*), e1) }
+		clause('DIV e e') { |_, e0, e1| e0.send(get_op(:/), e1) }
+	end
+	
+	class Environment < Environment
+		def initialize
+			@map = { :+ => 0, :- => 1, :* => 2, :/ => 3 }
+			@ops = [ :+, :-, :*, :/ ]
+		end
+		
+		def get_op(orig_op)
+			new_op = @ops[@map[orig_op]]
+			
+			@ops = @ops[1..-1] << @ops[0]
+			
+			new_op
+		end
+	end
+	
+	finalize
+end
+
+class ParserTester < Test::Unit::TestCase
+	def test_ambiguous_grammar
+		actual = AmbiguousParser.parse(RLTK::Lexers::Calculator.lex('1 + 2 * 3'), {:accept => :all})
+		assert_equal([7, 9], actual.sort)
+	end
+	
+	def test_array_args
+		actual = ArrayCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 2'))
+		assert_equal(3, actual)
+		
+		actual = ArrayCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 * 2 3'))
+		assert_equal(7, actual)
+		
+		actual = ArrayCalc.parse(RLTK::Lexers::Calculator.lex('* + 1 2 3'))
+		assert_equal(9, actual)
+	end
+	
+	def test_ebnf_parsing
+		################
+		# APlusBParser #
+		################
+		
+		assert_raise(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')))
+		assert_equal(4, APlusBParser.parse(ABLexer.lex('aaaab')))
+		
+		####################
+		# AQuestionBParser #
+		####################
+		
+		assert_raise(RLTK::NotInLanguage) { AQuestionBParser.parse(ABLexer.lex('aab')) }
+		assert_nil(AQuestionBParser.parse(ABLexer.lex('b')))
+		assert_not_nil(AQuestionBParser.parse(ABLexer.lex('ab')))
+		
+		################
+		# AStarBParser #
+		################
+		
+		assert_equal(0, AStarBParser.parse(ABLexer.lex('b')))
+		assert_equal(1, AStarBParser.parse(ABLexer.lex('ab')))
+		assert_equal(2, AStarBParser.parse(ABLexer.lex('aab')))
+		assert_equal(3, AStarBParser.parse(ABLexer.lex('aaab')))
+		assert_equal(4, AStarBParser.parse(ABLexer.lex('aaaab')))
+	end
+	
+	def test_environment
+		actual = RotatingCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 2'))
+		assert_equal(3, actual)
+		
+		actual = RotatingCalc.parse(RLTK::Lexers::Calculator.lex('/ 1 * 2 3'))
+		assert_equal(7, actual)
+		
+		actual = RotatingCalc.parse(RLTK::Lexers::Calculator.lex('- + 1 2 3'))
+		assert_equal(9, actual)
+		
+		parser = RotatingCalc.new
+		
+		actual = parser.parse(RLTK::Lexers::Calculator.lex('+ 1 2'))
+		assert_equal(3, actual)
+		
+		actual = parser.parse(RLTK::Lexers::Calculator.lex('/ 1 2'))
+		assert_equal(3, actual)
+	end
+	
+	def test_error_productions
+		assert_raise(DummyError1) { ErrorCalc.parse(RLTK::Lexers::Calculator.lex('1 + +')) }
+		assert_raise(DummyError2) { ErrorCalc.parse(RLTK::Lexers::Calculator.lex('1 - +')) }
+		
+		test_string  = "first line;\n"
+		test_string += "second line\n"
+		test_string += "third line;\n"
+		test_string += "fourth line\n"
+		
+		assert_raise(RLTK::HandledError) { ErrorLine.parse(ELLexer.lex(test_string)) }
+		
+		begin
+			ErrorLine.parse(ELLexer.lex(test_string))
+		rescue RLTK::HandledError => e
+			assert_equal(e.errors, [2,4])
+		end
+	end
+	
+	def test_infix_calc
+		actual = RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('1 + 2'))
+		assert_equal(3, actual)
+		
+		actual = RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('1 + 2 * 3'))
+		assert_equal(7, actual)
+		
+		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 *')) }
+	end
+	
+	def test_input
+		assert_raise(RLTK::BadToken) { RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::EBNF.lex('A B C')) }
+	end
+	
+	def test_postfix_calc
+		actual = RLTK::Parsers::PostfixCalc.parse(RLTK::Lexers::Calculator.lex('1 2 +'))
+		assert_equal(3, actual)
+		
+		actual = RLTK::Parsers::PostfixCalc.parse(RLTK::Lexers::Calculator.lex('1 2 3 * +'))
+		assert_equal(7, actual)
+		
+		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')) }
+	end
+	
+	def test_prefix_calc
+		actual = RLTK::Parsers::PrefixCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 2'))
+		assert_equal(3, actual)
+		
+		actual = RLTK::Parsers::PrefixCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 * 2 3'))
+		assert_equal(7, actual)
+		
+		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')) }
+	end
+end

data/test/tc_token.rb

@@ -0,0 +1,34 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2011/04/06
+# Description:	This file contains unit tests for the RLTK::Token class.
+
+############
+# Requires #
+############
+
+# Standard Library
+require 'test/unit'
+
+# Ruby Language Toolkit
+require 'rltk/token'
+
+#######################
+# Classes and Modules #
+#######################
+
+class TokenTester < Test::Unit::TestCase
+	def test_equal
+		t0 = RLTK::Token.new(:FOO, 0)
+		t1 = RLTK::Token.new(:FOO, 0)
+		t2 = RLTK::Token.new(:FOO, 1)
+		t3 = RLTK::Token.new(:BAR, 0)
+		t4 = RLTK::Token.new(:BAR, 1)
+		
+		assert_equal(t0, t1)
+		
+		assert_not_equal(t0, t2)
+		assert_not_equal(t0, t3)
+		assert_not_equal(t0, t4)
+	end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: rltk
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 1
+  - 1
+  - 0
+  version: 1.1.0
+platform: ruby
+authors: 
+- Chris Wailes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-27 00:00:00 Z
+dependencies: []
+
+description: The Ruby Language Toolkit provides classes for creatingcontext-free grammars, lexers, parsers, and abstract syntax trees.
+email: chris.wailes@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- AUTHORS
+- README
+- Rakefile
+- lib/rltk/cfg.rb
+- lib/rltk/lexer.rb
+- lib/rltk/lexers/ebnf.rb
+- lib/rltk/lexers/calculator.rb
+- lib/rltk/ast.rb
+- lib/rltk/parser.rb
+- lib/rltk/token.rb
+- lib/rltk/parsers/postfix_calc.rb
+- lib/rltk/parsers/infix_calc.rb
+- lib/rltk/parsers/prefix_calc.rb
+- test/tc_ast.rb
+- test/tc_token.rb
+- test/tc_cfg.rb
+- test/tc_parser.rb
+- test/tc_lexer.rb
+homepage: http://github.com/chriswailes/RLTK
+licenses: 
+- University of Illinois/NCSA Open Source License
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: The Ruby Language Toolkit
+test_files: 
+- test/tc_ast.rb
+- test/tc_token.rb
+- test/tc_cfg.rb
+- test/tc_parser.rb
+- test/tc_lexer.rb