simply_stored 0.3.9 → 0.5.0

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

@@ -1,55 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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
-