aurum 0.1.0

data/test/engine/lexer_test.rb

@@ -0,0 +1,52 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class LexerTest < Test::Unit::TestCase
+	def test_should_execute_recognize_token_action
+		specification = {:initial => {PATTERN_A => Aurum::RecognizeTokenAction.new('tokenA')}}
+		lexer = create_lexer specification, 'pattern_a'
+		symbol = lexer.next_symbol
+		assert_equal terminal('tokenA'), symbol
+		assert_equal 'pattern_a', symbol.value
+	end	
+	
+	def test_should_execute_shift_to_lexical_state_action
+		specification = {:initial => {PATTERN_A => Aurum::ChangeStateAction.new(:stateA)},
+			:stateA => {PATTERN_B => Aurum::RecognizeTokenAction.new('tokenB')}}
+		lexer = create_lexer specification, 'pattern_apattern_b'
+		symbol = lexer.next_symbol
+		assert_equal terminal('tokenB'), symbol
+		assert_equal 'pattern_apattern_b', symbol.value			
+	end
+	
+	def test_should_execute_shift_to_and_recognize_token_action
+		specification = {:initial => {PATTERN_A => Aurum::ChangeStateAction.new(:stateA),
+									  PATTERN_B => Aurum::RecognizeTokenAction.new('tokenC')},
+			:stateA => {PATTERN_B => Aurum::RecognizeTokenAndChangeStateAction.new('tokenB', :initial)}}
+		lexer = create_lexer specification, 'pattern_apattern_bpattern_b'
+		assert_equal terminal('tokenB'), lexer.next_symbol								
+		assert_equal terminal('tokenC'), lexer.next_symbol		
+	end
+	
+	def test_should_not_execute_ignore_action
+		specification = {:initial => {PATTERN_A => Aurum::RecognizeTokenAction.new('tokenA'),
+									  PATTERN_B => Aurum::IgnoreAction}}
+		lexer = create_lexer specification, 'pattern_bpattern_a'
+		symbol = lexer.next_symbol
+		assert_equal terminal('tokenA'), symbol
+		assert_equal 'pattern_a', symbol.value									  						
+	end
+	
+	def test_should_return_eof_for_empty_string
+		specification = {:initial => {PATTERN_A => Aurum::RecognizeTokenAction.new('tokenA'),
+									  PATTERN_B => Aurum::IgnoreAction}}
+		lexer = create_lexer specification, ''
+		assert_equal terminal('$eof'), lexer.next_symbol				
+	end
+			
+	def create_lexer specification, input
+		generator = Aurum::LexicalTableGenerator.new specification
+		table, accepts = generator.lexical_table
+		Aurum::Lexer.new table, accepts, generator.lexical_states, input			
+	end
+end

data/test/engine/semantic_attributes_test.rb

@@ -0,0 +1,15 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class SemanticAttributesTest < Test::Unit::TestCase
+
+    def test_s_attribute_should_be_a_object_has_arbitrary_attributes
+        attr = Aurum::Parser::SemanticAttributes.new
+        10.times do
+            name, value = '', rand(100)
+            5.times { name << (rand(26) + 97) }
+            eval "attr.#{name} = #{value}"
+            assert_equal value, eval("attr.#{name}")
+        end
+    end
+end

data/test/grammar_definition/character_class_definition_test.rb

@@ -0,0 +1,28 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class CharacterClassDefinitionTest < Test::Unit::TestCase
+    def setup
+        @character_class = Aurum::CharacterClassDefinition.new
+    end
+
+    def test_should_add_char_class_to_definition
+        @character_class.instance_eval do
+            alpha range(?a, ?z) + string('ABCDEF')
+        end
+        assert_equal 1, @character_class.definitions.size
+        alpha = @character_class.definitions[:alpha]
+        (?a..?z).each {|x| assert alpha.include?(x)}
+        (?A..?F).each {|x| assert alpha.include?(x)}
+    end
+
+    def test_should_not_redefine_char_class
+        @character_class.instance_eval do
+            alpha range(?a, ?z) + range(?A, ?Z)
+            alpha range(?0, ?9)            
+        end
+        assert_equal 1, @character_class.definitions.size
+        alpha = @character_class.definitions[:alpha]
+        (?0..?9).each {|x| assert !alpha.include?(x)}
+    end
+end

data/test/grammar_definition/grammar_definition_test.rb

@@ -0,0 +1,54 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class ExpressionGrammar < Aurum::Grammar
+	character_classes do
+		number range(?0, ?9)
+	end
+	
+	tokens do
+		ignore string(' ').one_or_more 
+		_number the(:number).one_or_more
+	end
+	
+	precedences do
+		operator '*', '/'
+		operator '+', '-'
+	end
+	
+	productions do
+		expression expression, '+', expression {expression.value = expression1.value + expression2.value}
+		expression expression, '-', expression {expression.value = expression1.value - expression2.value}
+		expression expression, '*', expression {expression.value = expression1.value * expression2.value}
+		expression expression, '/', expression {expression.value = expression1.value / expression2.value}
+		expression '(', expression, ')'
+		expression _number {expression.value = _number.value.to_i}
+	end
+end
+
+class GrammarDefinitionTest < Test::Unit::TestCase
+	def test_should_add_literal_to_lexer	
+		@lexer = ExpressionGrammar.lexer '21 + 35'
+		assert_recognize '21', terminal('_number')
+		assert_recognize '+', terminal('$literal_+')
+		assert_recognize '35', terminal('_number')
+	end
+	
+	def test_should_create_parser
+		@lexer = ExpressionGrammar.lexer '21 + 35'
+		@parser = ExpressionGrammar.start_from 'expression'		
+		assert_equal 56, @parser.parse(@lexer).value
+		@lexer = ExpressionGrammar.lexer '2 + 3 * 5'
+		assert_equal 17, @parser.parse(@lexer).value
+		@lexer = ExpressionGrammar.lexer '(2 + 3) * 5'
+		assert_equal 25, @parser.parse(@lexer).value
+		@lexer = ExpressionGrammar.lexer '2 + (3 + 5) * 7'
+		assert_equal 58, @parser.parse(@lexer).value				
+	end
+	
+	def assert_recognize lexeme, token
+		symbol = @lexer.next_symbol
+		assert_equal token, symbol
+		assert_equal lexeme, symbol.value
+	end
+end

data/test/grammar_definition/lexical_definition_test.rb

@@ -0,0 +1,56 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class LexicalDefinitionTest < Test::Unit::TestCase       
+    def setup
+        @specification = Aurum::LexicalSpecification.new
+    end
+
+    def test_should_add_token_recognized_action_to_pattern
+        pattern = @specification._id @specification.range(?a, ?z)
+        action = @specification.definitions[:initial][pattern]
+        assert_equal Aurum::RecognizeTokenAction.new('_id'), action
+    end	
+	
+	def test_should_add_change_state_action_to_pattern
+		pattern = @specification.shift_to :string, '"'
+		action = @specification.definitions[:initial][pattern]
+		assert_equal Aurum::ChangeStateAction.new(:string), action
+	end
+	
+	def test_should_add_user_define_action_to_pattern
+		pattern = @specification.match '"' do
+			user_defined
+		end
+		action = @specification.definitions[:initial][pattern]
+		assert action.kind_of?(Aurum::UserDefinedAction)
+		assert action.action
+	end
+	
+	def test_should_add_ignore_action_to_pattern
+		pattern = @specification.ignore ' '
+		action = @specification.definitions[:initial][pattern]
+		assert_equal Aurum::IgnoreAction, action				
+	end
+	
+	def test_should_add_recognize_and_change_state_action_to_pattern
+		pattern = @specification.recognize_and_shift_to :_token, :string, 'token'
+		action = @specification.definitions[:initial][pattern]
+		assert_equal Aurum::RecognizeTokenAndChangeStateAction.new('_token',:string), action
+	end		
+	
+	def test_should_add_patterns_to_lexical_state
+		@specification.shift_to :state, 'state_begin' do
+			_state_content range(?a, ?z)
+		end
+		assert_equal 1, @specification.definitions[:state].size
+	end	
+	
+	def test_should_add_patterns_to_all_states
+		@specification.within :state1, :state2 do
+			_state_content range(?a, ?z)
+		end
+		assert_equal 1, @specification.definitions[:state1].size
+		assert_equal 1, @specification.definitions[:state2].size
+	end
+end

data/test/grammar_definition/operator_precedence_definition_test.rb

@@ -0,0 +1,35 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class OperatorPrecedenceDefinitionTest < Test::Unit::TestCase
+	def setup
+		@precedence = Aurum::OperatorPrecedenceDefinition.new
+	end
+	
+	def test_should_define_opeators_precedence_according_to_the_order_they_defined 
+		@precedence.instance_eval do
+			operator '*', '/'
+			operator '+', '-'			
+		end
+		precedences = @precedence.precedences
+		assert_equal 2, precedences.size
+		assert_equal [terminal('$literal_*'), terminal('$literal_/')], precedences[0] 
+		assert_equal [terminal('$literal_+'), terminal('$literal_-')], precedences[1]		
+	end
+	
+	def test_should_define_left_associativity_of_operators
+		@precedence.instance_eval do
+			left _plus
+			left _minus			
+		end
+	    assert_equal [terminal('_plus'), terminal('_minus')], @precedence.associativities[:left]
+	end
+	
+	def test_should_define_right_associativity_of_operators
+		@precedence.instance_eval do
+			right _plus
+			right _plus			
+		end
+	    assert_equal [terminal('_plus')], @precedence.associativities[:right]
+	end
+end

data/test/grammar_definition/production_definition_test.rb

@@ -0,0 +1,60 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class ProductionDefinitionTest < Test::Unit::TestCase
+    def setup
+    	@grammar = Aurum::ProductionDefinition.new
+    end
+
+    def test_should_add_prodcution_to_definition
+        @grammar.instance_eval do
+            bnf  bnf, rlist
+        end
+        assert_equal 1, @grammar.__definitions.length
+        assert_equal [production(BNF, BNF, RLIST)].to_set, @grammar.__definitions[BNF]
+    end
+
+    def test_should_not_add_duplication_production_to_nonterminal
+        @grammar.instance_eval do
+            bnf  rlist, bnf
+            bnf  rlist, bnf
+        end
+        assert_equal 1, @grammar.__definitions.length
+        assert_equal [production(BNF, RLIST, BNF)].to_set, @grammar.__definitions[BNF]
+    end
+
+    def test_should_add_empty_production_to_definition
+        @grammar.instance_eval do
+            bnf _
+        end
+        assert_equal 1, @grammar.__definitions.length
+        assert_equal [production(BNF)].to_set, @grammar.__definitions[BNF]
+    end
+
+    def test_should_treat_string_literal_as_terminal
+        @grammar.instance_eval do
+            t t, '+', t
+        end
+        t = nonterminal('t')
+        assert_equal 1, @grammar.__definitions.length
+        assert_equal [production(t, t, terminal('$literal_+'), t)].to_set, @grammar.__definitions[t]
+    end
+
+    def test_should_treat_symbol_start_with_underscore_as_terminal
+        @grammar.instance_eval do
+            t _id, '+', _id
+        end
+        t, id = nonterminal('t'), terminal('_id')
+        assert_equal 1, @grammar.__definitions.length
+        assert_equal [production(t, id, terminal('$literal_+'), id)].to_set,  @grammar.__definitions[t]
+    end
+
+    def test_should_use_action_of_last_symbol_as_production_action
+        @grammar.instance_eval do
+            t _id, '+', _id { }
+            f t { }, t
+        end
+        assert @grammar.__definitions[nonterminal('t')].to_a.first.action
+        assert !@grammar.__definitions[nonterminal('f')].to_a.first.action
+    end
+end

data/test/lexical_table_generator/automata_test.rb

@@ -0,0 +1,74 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+Aurum::Automata.class_eval do
+    def move start, char
+        state = @table[start].find {|state| state.symbols.include? char}
+        state ? state.destination : nil
+    end
+end
+
+class AutomataTest < Test::Unit::TestCase
+    def test_should_connect_states
+        automata = Aurum::Automata.new 2
+        automata.connect 0, 'a'.to_char_set, 1
+        assert_equal 1, automata.move(0, ?a)
+    end
+
+    def test_should_contain_all_transitions_in_merged_automata
+        automata = Aurum::Automata.new 2
+        automata.connect 0, 'b'.to_char_set, 1
+        other_automata = Aurum::Automata.new
+        other_automata.merge! automata
+        assert_equal 1, other_automata.move(0, ?b)
+    end
+
+    def test_should_return_an_automata_with_reverse_transitions
+        automata = Aurum::Automata.new 3
+        automata.connect 0, 'a'.to_char_set, 1
+        automata.connect 0, 'b'.to_char_set, 2
+        reverse_automata = automata.reverse
+        assert_equal 0, reverse_automata.move(1, ?a)
+        assert_equal 0, reverse_automata.move(2, ?b)
+    end
+
+    def test_should_return_an_automata_with_same_transitions
+        automata = Aurum::Automata.new 2
+        automata.connect 0, 'b'.to_char_set, 1
+        assert_equal 1, automata.dup.move(0, ?b)
+    end
+
+    def test_alphabet_should_get_symbol_ac_and_mq
+        automata = Aurum::Automata.new 4
+        automata.connect 0, interval(?a, ?c), 1
+        automata.connect 2, interval(?m, ?q), 3
+        assert_alphabet [[interval(?a, ?c), [1]], [interval(?m, ?q), [3]]], automata, [0, 2]
+    end
+
+    def test_alphabet_should_get_symbol_ac_df_and_g
+        automata = Aurum::Automata.new 4
+        automata.connect 0, interval(?a, ?f), 1
+        automata.connect 2, interval(?d, ?g), 3
+        assert_alphabet [[interval(?a, ?c), [1]], [interval(?d, ?f), [1, 3]], [interval(?g), [3]]], automata, [0, 2]
+    end
+
+    def test_alphabet_should_get_symbol_ac_dg_and_hz
+        automata = Aurum::Automata.new 4
+        automata.connect 0, interval(?a, ?z), 1
+        automata.connect 2, interval(?d, ?g), 3
+        assert_alphabet [[interval(?a, ?c), [1]], [interval(?d, ?g), [1, 3]], [interval(?h, ?z), [1]]], automata, [0, 2]
+    end
+
+    def assert_alphabet expected, automata, states
+        index = 0
+        automata.alphabet states do |states, symbols|
+            assert_equal expected[index][0].intervals, symbols.intervals
+            assert_equal expected[index][1], states
+            index += 1
+        end
+    end
+
+    def interval first, last = first
+        Aurum::CharacterSet::Interval.new(first, last).to_char_set
+    end
+end

data/test/lexical_table_generator/character_set_test.rb

@@ -0,0 +1,73 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class CharacterSetTest < Test::Unit::TestCase
+    def test_should_add_string_literal_to_character_set
+        char_set = Aurum::CharacterSet.new
+        char_set << 'age'
+        assert char_set.intervals.include?(Aurum::CharacterSet::Interval.new(?a))
+        assert char_set.intervals.include?(Aurum::CharacterSet::Interval.new(?g))
+        assert char_set.intervals.include?(Aurum::CharacterSet::Interval.new(?e))
+    end
+
+    def test_should_add_range_to_character_set
+        char_set = Aurum::CharacterSet.new
+        char_set << (?a..?z)
+        assert char_set.intervals.include?(Aurum::CharacterSet::Interval.new(?a, ?z))
+    end
+
+    def test_should_merge_intervals_in_character_set
+        char_set = Aurum::CharacterSet.new
+        char_set << (?a..?d)
+        char_set << (?b..?f)
+        assert char_set.intervals.include?(Aurum::CharacterSet::Interval.new(?a, ?f))
+    end
+
+    def test_should_delete_interval_in_character_set
+        char_set = Aurum::CharacterSet.new
+        char_set << (?a..?d)
+        char_set.delete 'bc'
+        assert char_set.intervals.include?(Aurum::CharacterSet::Interval.new(?a))
+        assert char_set.intervals.include?(Aurum::CharacterSet::Interval.new(?d))
+    end
+
+    def test_should_return_all_points_in_character_set
+        char_set = Aurum::CharacterSet.new
+        char_set << (?a..?b)
+        char_set << (?d..?e)                                
+        points = char_set.to_points 1
+        assert_equal [point(?a, true, 1), point(?b, false, 1), point(?d, true, 1), point(?e, false, 1)], points
+    end
+
+    def test_should_return_sum_of_2_character_sets
+        char_set_a = Aurum::CharacterSet.new
+        char_set_a << (?a..?g)
+        char_set_b = Aurum::CharacterSet.new
+        char_set_b << (?h..?z)
+        assert (char_set_a + char_set_b).intervals.include?(Aurum::CharacterSet::Interval.new(?a, ?z))
+    end
+
+    def test_should_return_sum_of_character_set_and_string
+        char_set = Aurum::CharacterSet.new
+        char_set << (?h..?z)
+        assert (char_set + 'gfedcba').intervals.include?(Aurum::CharacterSet::Interval.new(?a, ?z))
+    end    
+
+    def test_should_return_sub_of_2_character_sets
+        char_set_a = Aurum::CharacterSet.new
+        char_set_a << (?a..?z)
+        char_set_b = Aurum::CharacterSet.new
+        char_set_b << (?a..?d)
+        assert (char_set_a - char_set_b).intervals.include?(Aurum::CharacterSet::Interval.new(?e, ?z))
+    end
+
+    def test_should_return_sub_of_character_set_and_string
+        char_set = Aurum::CharacterSet.new
+        char_set << (?a..?z)
+        assert (char_set - 'abcd').intervals.include?(Aurum::CharacterSet::Interval.new(?e, ?z))
+    end        
+
+    def point char, start, destination
+        Aurum::CharacterSet::Point.new char, start, destination
+    end
+end