aurum 0.1.1 → 0.2.0

data/test/parsing_table_generator/lr_item_test.rb

@@ -1,27 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../')
-require 'test_helper'
-
-class LRItemTest < Test::Unit::TestCase
-    def test_should_return_dot_symbol
-        assert_equal T, LR_item(0, E, T, ID).dot_symbol
-        assert_equal ID, LR_item(1, E, T, ID).dot_symbol
-    end
-
-    def test_should_be_handle_if_at_right_most_position
-        assert LR_item(2, E, T, ID).is_handle
-        assert !LR_item(1, E, T, ID).is_handle
-        assert LR_item(0, E).is_handle
-    end
-
-    def test_should_be_kernel_if_not_at_left_most_position
-        assert LR_item(2, E, T, ID).is_kernel
-        assert LR_item(1, E, T, ID).is_kernel
-        assert !LR_item(0, E, T, ID).is_kernel
-    end   
-
-    def test_should_return_position_to_end_as_second_part
-        assert_equal [T, ID], LR_item(0, E, T, ID).second_part
-        assert_equal [ID], LR_item(1, E, T, ID).second_part
-        assert_equal [], LR_item(2, E, T, ID).second_part
-    end
-end

data/test/parsing_table_generator/parsing_table_state_test.rb

@@ -1,39 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../')
-require 'test_helper'
-
-class ParsingTableStateTest < Test::Unit::TestCase
-    def test_should_equal_to_state_with_same_items
-        state1 = parsing_table_state LR_item(1, E, T, T), LR_item(1, E, T)
-        state2 = parsing_table_state LR_item(1, E, T), LR_item(1, E, T, T)
-        assert_equal state1, state2
-    end
-
-    def test_should_be_read_reducable_if_contains_one_and_only_one_handle
-        assert parsing_table_state(LR_item(1, E, ID)).read_reduce
-        assert !parsing_table_state(LR_item(1, E, T, T)).read_reduce
-        assert !parsing_table_state(LR_item(1, E, T, T), LR_item(1, E, T)).read_reduce
-    end
-
-    def test_should_not_add_duplicate_action
-        state = parsing_table_state(LR_item(1, E, T))
-        state[E] << Aurum::ReduceAction.new(production(E, T), true)
-        state[E] << Aurum::ReduceAction.new(production(E, T), true)
-        assert_equal 1, state[E].length
-    end
-
-    def test_should_be_consistent_if_contains_one_and_only_one_handle
-        assert  !parsing_table_state(LR_item(1, E, T)).inconsistent?
-    end
-
-    def test_should_be_consistent_if_contains_no_handle
-        assert  !parsing_table_state(LR_item(1, E, T, ID), LR_item(1, E, F, ID), LR_item(1, E, ID, F)).inconsistent?
-    end
-
-    def test_should_be_inconsistent_if_contains_handle_and_other_kernal_items
-        assert parsing_table_state(LR_item(1, E, T), LR_item(1, E, T, ID)).inconsistent?
-    end
-
-    def test_should_return_all_direct_read_symbols
-    	assert_equal [T].to_set, parsing_table_state(LR_item(1, E, T, T), LR_item(1, E, T)).direct_read
-    end
-end

data/test/parsing_table_generator/precedence_table_test.rb

@@ -1,28 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../')
-require 'test_helper'
-
-class PrecedenceTableTest < Test::Unit::TestCase
-    OP_A, OP_B = terminal('+'), terminal('-')
-
-    def test_should_return_one_if_op_a_has_higher_precedence
-        precedences = precedence_table [[OP_A], [OP_B]]
-        assert_equal 1, precedences.compare(OP_A, OP_B)
-    end
-
-    def test_should_return_minus_one_if_op_a_has_lower_precedence
-        precedences = precedence_table [[OP_A], [OP_B]]
-        assert_equal -1, precedences.compare(OP_B, OP_A)
-    end
-
-    def test_should_return_one_if_ops_same_precedence_and_left_associativity
-        precedences = precedence_table [[OP_A, OP_B]] 
-        assert_equal 1, precedences.compare(OP_A, OP_B)
-        assert_equal 1, precedences.compare(OP_B, OP_A)
-    end
-
-    def test_should_return_minus_one_if_ops_same_precedence_and_right_associativity
-        precedences = precedence_table [[OP_A, OP_B]], :right => [OP_A, OP_B]
-        assert_equal -1, precedences.compare(OP_A, OP_B)
-        assert_equal -1, precedences.compare(OP_B, OP_A)
-    end
-end

data/test/parsing_table_generator/production_test.rb

@@ -1,9 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../')
-require 'test_helper'
-
-class ProductionTest < Test::Unit::TestCase
-    def test_should_return_last_terminal_as_opearator
-        production = production E, E, terminal('+'), E
-        assert_equal terminal('+'), production.operator 
-    end
-end

data/test/test_helper.rb

@@ -1,103 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'test/unit'
-require 'aurum'
-
-def terminal name
-    Aurum::Symbol.new name, true
-end
-
-def nonterminal name
-    Aurum::Symbol.new name, false
-end
-
-def production nt, *symbols 
-	Aurum::Production.new nt, symbols 
-end
-
-def LR_item position, nt, *symbols
-    Aurum::ParsingTableGenerator::LRItem.new production(nt, *symbols), position
-end
-
-def parsing_table_state *items
-    Aurum::ParsingTableGenerator::State.new items
-end
-
-def parser_generator(definition, precedences = [], associativities = {:left => [], :right => []}) 
-    Aurum::ParsingTableGenerator.new definition, precedences
-end
-
-def shift state
-    Aurum::ShiftAction.new state, false
-end
-
-def lookahead_shift state
-    Aurum::ShiftAction.new state, true
-end
-
-def read_reduce production_no
-    Aurum::ReduceAction.new production_no, true
-end
-
-def reduce production_no
-    Aurum::ReduceAction.new production_no, false
-end
-
-def precedence_table(precedences, associativities = {:left => [], :right => []})
-    Aurum::ParsingTableGenerator::PrecedenceTable.new precedences, associativities 
-end
-
-String.class_eval do
-    def to_char_set
-        char_set = Aurum::CharacterSet.new
-        char_set << self
-        char_set
-    end
-
-    def to_pattern
-        Aurum::Pattern.from_string self
-    end
-end
-
-Aurum::CharacterSet.class_eval do
-    def intervals
-        @intervals
-    end
-end
-
-Test::Unit::TestCase.class_eval do
-    START, E, T, F, ID = nonterminal('$start'), nonterminal('E'), nonterminal('T'), nonterminal('F'), terminal('id')
-
-    SIMPLE_GRAMMAR_LR0 = {
-    E => [production(E, T, terminal('+'), T)],
-    T => [production(T, ID)]
-    }
-
-    EXPRESSION_GRAMMAR_LALR1 = {
-    E => [production(E, E, terminal('+'), T), production(E, T)],
-    T => [production(T, T, terminal('*'), F), production(T, F)],
-    F => [production(F, terminal('('), E, terminal(')')), production(F, ID)],
-    }
-
-    BNF, RLIST, RULE, SLIST = nonterminal('bnf'), nonterminal('rlist'), nonterminal('rule'), nonterminal('slist')
-    BNF_GRAMMAR_LALR2 = {
-    BNF   => [production(BNF, RLIST)],
-    RLIST => [production(RLIST), production(RLIST, RLIST, RULE)],
-    RULE  => [production(RULE, terminal('s'), terminal('->'), SLIST)],
-    SLIST => [production(SLIST), production(SLIST, SLIST, terminal('s'))]
-    }
-
-    STATEMENT = nonterminal 'statement'
-    IF_GRAMMAR_LALR2 = {
-    STATEMENT => [production(STATEMENT, terminal('if'), STATEMENT, terminal('then'), STATEMENT),
-    production(STATEMENT, terminal('if'), STATEMENT, terminal('then'), STATEMENT, terminal('else'), STATEMENT),
-    production(STATEMENT, terminal('stmt'))]
-    }
-
-    EXPRESSION_GRAMMAR = { E => [production(E, E, terminal('+'), E), production(E, E, terminal('*'), E), production(E, ID)]}
-    NOT_LALR_GRAMMAR = EXPRESSION_GRAMMAR
-
-    PATTERN_A, PATTERN_B, PATTERN_C = 'pattern_a'.to_pattern, 'pattern_b'.to_pattern, 'pattern_c'.to_pattern,
-    ABABB = Aurum::Pattern.concat(('a'.to_pattern | 'b'.to_pattern).kleene, 'abb'.to_pattern)
-end
-
-