aurum 0.1.1 → 0.2.0

data/test/engine/lexer_test.rb

@@ -1,59 +0,0 @@
-$:.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 test_should_return_unknown_if_not_recognized
-		specification = {:initial => {PATTERN_A => Aurum::RecognizeTokenAction.new('tokenA'),
-									  PATTERN_B => Aurum::IgnoreAction}}
-		lexer = create_lexer specification, 'whatever'
-		assert_equal terminal('$unknown'), 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

@@ -1,15 +0,0 @@
-$:.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

@@ -1,28 +0,0 @@
-$:.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) + enum('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

@@ -1,55 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../')
-require 'test_helper'
-=begin
-class ExpressionGrammar < Aurum::Grammar
-	character_classes do
-		number range(?0, ?9)
-	end
-	
-	tokens do
-		ignore string(' ').one_or_more 
-		_number 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
-=end

data/test/grammar_definition/lexical_definition_test.rb

@@ -1,56 +0,0 @@
-$:.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

@@ -1,35 +0,0 @@
-$:.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

@@ -1,60 +0,0 @@
-$:.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

@@ -1,74 +0,0 @@
-$:.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

@@ -1,73 +0,0 @@
-$:.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