simply_stored 0.1.4

data/test/vendor/dhaka-2.2.1/test/chittagong/chittagong_parser_test.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + '/chittagong_grammar'
+begin
+  require File.dirname(__FILE__) + "/chittagong_parser"
+rescue LoadError
+  puts "Please run the rake command in the root folder to generate the lexer and parser required for this test."
+  exit
+end
+
+class TestChittagongParser < Test::Unit::TestCase
+
+  def test_parses_a_series_of_statements
+    token_stream = build_tokens(
+      'newline',
+      'word_literal', '=', 'numeric_literal', 'newline',
+      'print', 'word_literal', 'newline',
+      'newline',
+      'word_literal', '=', 'word_literal', 'newline',
+      'newline', Dhaka::END_SYMBOL_NAME
+    )
+    
+    result = ChittagongParser.parse(token_stream)
+    
+    assert_equal(["single_term",
+     "some_terms",
+     "variable_name",
+     "literal",
+     "assignment_statement",
+     "main_body_simple_statement",
+     "single_main_body_statement",
+     "single_term",
+     "variable_name",
+     "variable_reference",
+     "print_statement",
+     "main_body_simple_statement",
+     "multiple_main_body_statements",
+     "single_term",
+     "multiple_terms",
+     "variable_name",
+     "variable_name",
+     "variable_reference",
+     "assignment_statement",
+     "main_body_simple_statement",
+     "multiple_main_body_statements",
+     "single_term",
+     "multiple_terms",
+     "some_terms",
+     "program"], result.linearize.collect {|node| node.production.name})
+     
+  end
+
+  def build_tokens *symbol_names
+    symbol_names.collect {|symbol_name| Dhaka::Token.new(symbol_name, nil, nil)}
+  end
+end 

data/test/vendor/dhaka-2.2.1/test/chittagong/chittagong_test.rb

@@ -0,0 +1,170 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/chittagong_grammar"
+require File.dirname(__FILE__) + "/chittagong_lexer_specification"
+begin
+  require File.dirname(__FILE__) + "/chittagong_parser"
+  require File.dirname(__FILE__) + "/chittagong_lexer"
+rescue LoadError
+  puts "Please run the rake command in the root folder to generate the lexer and parser required for this test."
+  exit
+end
+require File.dirname(__FILE__) + "/chittagong_evaluator"
+
+class TestChittagong < Test::Unit::TestCase
+  
+  def fact(n)
+    return 1 if n==1
+    n * fact(n-1)
+  end
+  
+  def program_output program
+    output_stream = []
+    parse_result = ChittagongParser.parse(ChittagongLexer.lex(program))
+    result = ChittagongEvaluator.new([{}], output_stream).evaluate(parse_result)
+    return result, output_stream
+  end
+  
+  def test_iterative_fibonacci_without_functions
+    program = "
+
+    n = 1
+    a = 0
+    b = 1
+    while n < 10
+      print b
+      c = a
+      a = b
+      b = c + b
+      n = n + 1
+    end
+    
+    "
+
+    result, output_stream = program_output(program)
+    assert_equal(["1.0", "1.0", "2.0", "3.0", "5.0", "8.0", "13.0", "21.0", "34.0"], output_stream)
+  end
+
+  def test_iterative_fibonacci_with_functions
+    program = "
+
+    def fib(n)
+      i = 0
+      a = 0
+      b = 1
+      while i < n
+        c = a
+        a = b
+        b = c + b
+        i = i + 1
+      end
+      return b
+    end
+    
+    x = 0
+    while x < 9
+      print fib(x)
+      x = x + 1
+    end
+    
+    "
+    result, output_stream = program_output(program)
+    assert_equal(["1.0", "1.0", "2.0", "3.0", "5.0", "8.0", "13.0", "21.0", "34.0"], output_stream)
+  end
+  
+  def test_recursive_factorial
+    program = "
+    def fact(n)
+      if n == 1 
+        return 1
+      end
+      return n * fact(n-1)
+    end
+
+    n = 1
+    while n < 11
+      print fact(n)
+      n = n+1
+    end"
+    
+    result, output_stream = program_output(program)
+    assert_equal((1..10).collect {|i| fact(i).to_f.to_s}, output_stream)
+  end
+  
+  def test_various_things
+    program = "
+    
+    a = 1
+    b = 2
+    c = 3
+    
+    def foo(a, b, c)
+      print a
+      print b
+      print c
+      return c
+      print 999
+    end
+    
+    foo(4, a, 6)
+    
+    "
+   
+    result, output_stream = program_output(program)
+    assert_equal(["4.0", "1.0", "6.0"], output_stream)
+  end
+  
+  def test_if_else_block
+    program = "
+
+    def foo(a, b)
+      if a < b
+        print 1
+      else
+        print 2
+      end
+    end
+
+    foo(1, 2)
+    foo(2, 1)
+
+    "
+
+    result, output_stream = program_output(program)
+    assert_equal(["1.0", "2.0"], output_stream)
+  end
+  
+  def test_no_arg_functions
+    program = "
+
+    def foo()
+      print 1
+      print 2
+    end
+    foo()
+
+    "
+
+    result, output_stream = program_output(program)
+    assert_equal(["1.0", "2.0"], output_stream)
+  end
+
+  def test_decimal_numbers
+    program = "
+    print 0.2347 * 23.34
+    a = 1.012
+    b = 345.44
+    c = 0.234
+    print (a^b)/c
+    def foo(a)
+      print a
+    end
+    foo(3.4)
+    "
+
+    result, output_stream = program_output(program)
+    assert_equal(["5.477898", "263.233029427781", "3.4"], output_stream)
+  end
+
+  
+  
+end

data/test/vendor/dhaka-2.2.1/test/core/another_lalr_but_not_slr_grammar.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__)+'/../dhaka_test_helper'
+
+class AnotherLALRButNotSLRGrammar < Dhaka::Grammar
+
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    assignment %w| L = R |
+    rhs        %w| R |
+  end
+
+  for_symbol('L') do
+    contents   %w| * R |
+    identifier %w| id |
+  end
+
+  for_symbol('R') do
+    l_value    %w| L |
+  end
+
+end
+

data/test/vendor/dhaka-2.2.1/test/core/compiled_parser_test.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/simple_grammar"
+eval(Dhaka::Parser.new(SimpleGrammar).compile_to_ruby_source_as(:SimpleParser))
+
+class TestCompiledParser < Test::Unit::TestCase
+  def test_compiled_parser_generates_parse_tree_for_simple_grammar
+    parse_tree = SimpleParser.parse(build_tokens(%w| ( n - ( n - n ) ) - n # | +[Dhaka::END_SYMBOL_NAME]))
+    assert_equal \
+      ["literal",
+       "term",
+       "literal",
+       "term",
+       "literal",
+       "subtraction",
+       "parenthetized_expression",
+       "subtraction",
+       "parenthetized_expression",
+       "term",
+       "literal",
+       "subtraction",
+       "expression",
+       "start"], parse_tree.linearize.collect {|node| node.production.name}
+  end
+
+  def test_parse_result_has_error_result_if_only_end_token_passed
+    parse_result = SimpleParser.parse(build_tokens([Dhaka::END_SYMBOL_NAME]))
+    assert parse_result.has_error?
+  end
+  
+  def test_parse_result_is_nil_if_no_end_token
+    parse_result = SimpleParser.parse(build_tokens(%w| n - n |))
+    assert_nil(parse_result)
+  end
+
+  def test_parser_returns_error_result_with_index_of_bad_token_if_parse_error
+    parse_result = SimpleParser.parse(build_tokens(['(', '-', ')', Dhaka::END_SYMBOL_NAME]))
+    assert parse_result.has_error?
+    assert_equal '-', parse_result.unexpected_token.symbol_name
+  end
+
+  def build_tokens(token_symbol_names)
+    token_symbol_names.collect {|symbol_name| Dhaka::Token.new(symbol_name, nil, nil)}
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/dfa_test.rb

@@ -0,0 +1,170 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+
+class TestDFA < Test::Unit::TestCase
+  def test_build_AST_from_parse_tree_and_compute_follow_first_and_last
+    root      = Dhaka::LexerSupport::RegexParser.parse(Dhaka::LexerSupport::RegexTokenizer.tokenize("(a|b)*abb"))
+    star_node = root.left.left.left.left
+    or_node   = star_node.child
+    first_a   = or_node.children[0]
+    first_b   = or_node.children[1]
+    second_a  = root.left.left.left.right
+    second_b  = root.left.left.right
+    last_b    = root.left.right
+    sentinel  = root.right
+  
+    assert(!root.nullable)
+    assert(!root.left.nullable)
+    assert(!root.left.left.nullable)
+    assert(star_node.nullable)
+  
+    assert_equal(Set.new([first_a, first_b, second_a]), root.first)
+    assert_equal(Set.new([last_b]), root.left.last)
+  
+    root.calculate_follow_sets
+  
+    assert_equal(Set.new([first_a, first_b, second_a]), first_a.follow_set)
+    assert_equal(Set.new([first_a, first_b, second_a]), first_b.follow_set)
+    assert_equal(Set.new([second_b]), second_a.follow_set)
+    assert_equal(Set.new([last_b]), second_b.follow_set)
+    assert_equal(Set.new([sentinel]), last_b.follow_set)
+  end
+
+  def test_DFA_raises_exception_if_empty_regex
+    machine = Dhaka::LexerSupport::DFA.new("")
+    flunk "Should have thrown an unexpected end of regex exception"
+  rescue Dhaka::LexerSupport::InvalidRegexException => e
+    assert_equal("Unexpected end of regex.", e.message)
+  end
+
+  def test_DFA_raises_exception_if_error_parsing_regex
+    machine = Dhaka::LexerSupport::DFA.new("(a|b)*+abb")
+    flunk "Should have thrown an unexpected token exception"
+  rescue Dhaka::LexerSupport::InvalidRegexException => e
+    assert_equal("Unexpected token +: (a|b)*>>>+abb", e.message)
+  end
+
+  def test_match_a_regex
+    machine = Dhaka::LexerSupport::DFA.new("(a|b)*abb")
+    assert_full_match(machine, "abababb")
+    assert_full_match(machine, "ababaabb")
+    assert_empty(machine.match("abababab"))
+    assert_equal("abababb", machine.match("abababbc"))
+    assert_equal("abababb", machine.match("abababbaa"))
+  end
+
+  def test_match_a_regex_with_optional_characters_at_the_end
+    machine = Dhaka::LexerSupport::DFA.new("bad(c|d)+(ab)*")
+    assert_full_match(machine, "badccddabab")
+    assert_full_match(machine, "baddcc")
+    assert_empty(machine.match("badab"))
+    assert_empty(machine.match("bacdab"))
+  end
+
+  def test_match_a_nullable_regex
+    machine = Dhaka::LexerSupport::DFA.new("(ab)*")
+    assert_full_match(machine, "abab")
+    assert_full_match(machine, "ab")
+    assert_full_match(machine, "")
+    assert_equal("", machine.match("b"))
+  end
+
+  def test_match_a_regex_with_the_dot_character
+    machine = Dhaka::LexerSupport::DFA.new("ab.*cd")
+    assert_full_match(machine, "abacd")
+    assert_full_match(machine, "abcd")
+    assert_full_match(machine, "abAcd")
+    assert_empty(machine.match("ab999c"))
+  end
+
+  def test_match_a_regex_with_sets
+    machine = Dhaka::LexerSupport::DFA.new("ab[j-lu]*cd")
+    assert_empty(machine.match("abacd"))
+    assert_full_match(machine, "abcd")
+    assert_full_match(machine, "abjklucd")
+    assert_empty(machine.match("abijklucd"))
+    assert_empty(machine.match("ab999c"))
+  end
+
+  def test_match_a_regex_with_negative_sets
+    machine = Dhaka::LexerSupport::DFA.new("ab[^j-lr]*cd")
+    assert_full_match(machine, "abcd")
+    assert_empty(machine.match("abjcd"))
+    assert_empty(machine.match("abrcd"))
+    assert_empty(machine.match("abijklucd"))
+    assert_full_match(machine, "abyqcd")
+  end
+
+  def test_match_a_regex_with_sets_containing_escaped_characters
+    machine = Dhaka::LexerSupport::DFA.new("ab[\\^\\-.]*cd")
+    assert_full_match(machine, "abcd")
+    assert_empty(machine.match("abjcd"))
+    assert_full_match(machine, "ab^-.cd")
+    assert_empty(machine.match("abijklucd"))
+    assert_empty(machine.match("ab\\cd"))
+  end
+
+  def test_match_a_regex_using_unescaped_caret_and_dash_characters
+    machine = Dhaka::LexerSupport::DFA.new("(\\^-)+")
+    assert_full_match(machine, "^-")
+    assert_full_match(machine, "^-^-")
+    assert_empty(machine.match("?cd"))
+  end
+
+  def test_match_a_regex_using_escape_characters
+    machine = Dhaka::LexerSupport::DFA.new(%q/(-\?\(\)\\\\)*/)
+    assert_full_match(machine, "-?()\\")
+  end
+
+  def test_match_a_regex_using_lt_and_gt
+    machine = Dhaka::LexerSupport::DFA.new('<.+>')
+    assert_full_match(machine, "<ab>")
+    assert_full_match(machine, "<absdf><sdg><sse>")
+    assert_empty(machine.match("ab>"))
+  end
+
+  def test_simulating_curly_brace_quantifiers
+    machine = Dhaka::LexerSupport::DFA.new('aaa?a?a?')
+    assert_full_match(machine, "aa")
+    assert_full_match(machine, "aaa")
+    assert_full_match(machine, "aaaa")
+    assert_full_match(machine, "aaaaa")
+    assert_equal("aaaaa", machine.match("aaaaaa"))
+    assert_empty(machine.match("a"))
+  end
+  
+  def test_matching_a_regex_with_lookahead
+    machine = Dhaka::LexerSupport::DFA.new('ab/cd')
+    assert_equal("ab", machine.match("abcd"))
+    assert_empty(machine.match("ab"))
+    assert_empty(machine.match("abef"))
+  end
+  
+  def test_matching_a_regex_with_nullable_pre_lookahead_regex
+    machine = Dhaka::LexerSupport::DFA.new('(ab)*/cd')
+    assert_equal("ab", machine.match("abcd"))
+    assert_equal("ababab", machine.match("abababcd"))
+    assert_empty(machine.match("ababc"))
+    assert_empty(machine.match("abef"))
+  end
+
+  def test_matching_a_regex_with_post_lookahead_characters_in_common_with_pre_lookahead_characters
+    machine = Dhaka::LexerSupport::DFA.new('(ab)+/abcd')
+    assert_equal("ababab", machine.match("abababcd"))
+    assert_empty(machine.match("ab"))
+    assert_empty(machine.match("abef"))
+  end
+  
+  def test_machine_with_nullable_lookahead
+    machine = Dhaka::LexerSupport::DFA.new(":/[aA\n\r\t]*")
+    assert_equal(":", machine.match(":"))
+  end
+  
+  private
+    def assert_full_match(machine, input)
+      assert_equal(input, machine.match(input))
+    end
+    
+    def assert_empty(input)
+      assert(input.empty?)
+    end
+end

data/test/vendor/dhaka-2.2.1/test/core/evaluator_test.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + '/simple_grammar'
+
+class TestEvaluator < Test::Unit::TestCase
+  def test_throws_exception_if_evaluation_rules_not_completely_defined_and_raise_error_option_set_to_true
+    assert_raise(Dhaka::EvaluatorDefinitionError) do 
+      eval(
+      "class IncompleteSimpleEvaluator < Dhaka::Evaluator
+        self.grammar = SimpleGrammar
+        define_evaluation_rules(:raise_error => true) do
+          for_start do
+            something
+          end
+        
+          for_literal do
+            something
+          end
+        end
+      end")
+    end
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/grammar_test.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + '/simple_grammar'
+
+class SimpleGrammarTest < Test::Unit::TestCase
+  def setup
+    @grammar = SimpleGrammar
+  end
+  
+  def test_loads_symbols_and_classifies_them
+    expected_non_terminals = Set.new(['E', 'S', 'T', Dhaka::START_SYMBOL_NAME])
+    expected_terminals     = Set.new(['-', 'n', '(', ')', '#', Dhaka::END_SYMBOL_NAME])
+    assert_equal(expected_non_terminals, Set.new(@grammar.non_terminal_symbols.collect {|symbol| symbol.name}))
+    assert_equal(expected_terminals, Set.new(@grammar.terminal_symbols.collect {|symbol| symbol.name}))
+  end
+  
+  def test_creates_productions
+    productions_for_E = @grammar.productions_for_symbol(@grammar.symbol_for_name('E'))
+    assert(productions_for_E.size == 2)
+    expected_productions_for_E = Set.new(['subtraction E ::= E - T', 'term E ::= T'])
+    assert_equal(expected_productions_for_E, Set.new(productions_for_E.collect {|production| production.to_s}))
+    productions_for_start = @grammar.productions_for_symbol(@grammar.start_symbol)
+    assert(productions_for_start.size == 1)
+    expected_productions_for_start = Set.new(['start _Start_ ::= S #'])
+    assert_equal(expected_productions_for_start, Set.new(productions_for_start.collect {|production| production.to_s}))
+  end
+  
+  def test_symbols_in_productions_use_the_flyweight_pattern
+    assert_same(@grammar.production_named('subtraction').symbol, @grammar.production_named('term').symbol)
+    assert_same(@grammar.production_named('expression').expansion.first, @grammar.production_named('subtraction').expansion.first)
+  end
+  
+  def test_first_with_non_terminal
+    expected_symbols = Set.new(['(', 'n'])
+    assert_equal(expected_symbols, Set.new(@grammar.first(@grammar.symbol_for_name('E')).collect {|symbol| symbol.name}))
+  end
+
+  def test_first_with_terminal
+    expected_symbols = Set.new(['('])
+    assert_equal(expected_symbols, Set.new(@grammar.first(@grammar.symbol_for_name('(')).collect {|symbol| symbol.name}))
+  end
+
+  def test_computes_closures_and_channels_given_a_kernel
+    start_production  = @grammar.production_named('start')
+    start_item        = Dhaka::Item.new(start_production, 0)
+    kernel            = Set.new([start_item])
+    closure, channels = @grammar.closure(kernel)
+    expected_items    = Set.new(['_Start_ ::= -> S # []',
+                              'S ::= -> E []',
+                              'E ::= -> E - T []',
+                              'E ::= -> T []',
+                              'T ::= -> n []',
+                              'T ::= -> ( E ) []'])
+    expected_channels = Set.new([
+          'Spontaneous Channel from E ::= -> E - T [] to E ::= -> E - T []',
+          'Spontaneous Channel from S ::= -> E [] to E ::= -> T []',
+          'Spontaneous Channel from E ::= -> T [] to T ::= -> n []',
+          'Spontaneous Channel from S ::= -> E [] to E ::= -> E - T []',
+          'Spontaneous Channel from E ::= -> T [] to T ::= -> ( E ) []',
+          'Spontaneous Channel from E ::= -> E - T [] to E ::= -> T []',
+          'Spontaneous Channel from _Start_ ::= -> S # [] to S ::= -> E []'
+          ])
+    assert_equal(expected_items, Set.new(closure.values.collect{|item| item.to_s}))
+    assert_equal(expected_channels, Set.new(channels.values.collect{|set| set.to_a}.flatten.collect{|item| item.to_s}))
+  end
+  
+  def test_export_grammar_to_bnf
+    assert_equal(
+'
+"_Start_" :
+  | "S" "#"
+
+"S" :
+  | "E"
+
+"E" :
+  | "E" "-" "T"
+  | "T"
+
+"T" :
+  | "n"
+  | "(" "E" ")"', @grammar.to_bnf)
+  end
+end

data/test/vendor/dhaka-2.2.1/test/core/lalr_but_not_slr_grammar.rb

@@ -0,0 +1,19 @@
+class LALRButNotSLRGrammar < Dhaka::Grammar
+
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    start %w| E |
+  end
+
+  for_symbol('E') do
+    E_Aa  %w| A a |
+    E_bAc %w| b A c |
+    E_dc  %w| d c |
+    E_bda %w| b d a |
+  end
+
+  for_symbol('A') do
+    A_d   %w| d |
+  end
+
+end
+