simply_stored 0.3.9 → 0.5.0

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

@@ -1,276 +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_driver"
-
-class TestChittagongDriver < Test::Unit::TestCase
-  def setup
-    @driver = ChittagongDriver.new
-  end
-  
-  def test_return_statement_not_allowed_in_main
-    # Programs with problems
-    program = "
-
-    if 1 > 2
-      return 5
-    end
-
-    print 2
-    "
-    assert_equal(
-    "Unexpected token return:
-
-
-    if 1 > 2
-      >>>return 5
-    end
-
-    print 2
-    ", @driver.run(program))
-  end
-  
-  def test_catches_unexpected_end_of_input
-    program = "
-      def"
-    assert_equal("Unexpected end of file.", @driver.run(program))
-  end
-  
-  def test_catches_unexpected_characters
-    program = "
-      print 2
-      def #}
-        "
-    assert_equal(
-    "Unexpected character #:
-
-      print 2
-      def >>>#}
-        ", @driver.run(program))
-  end
-  
-  def test_catches_undefined_variables
-    program = "
-      x = 1
-      y = 2
-      def foo(n)
-        return 2
-      end
-      foo(1)
-      
-      if x > y
-        print 999
-        print 777
-      else
-        print 66
-      end
-      
-      print x
-      print y
-      print 2*3+c
-      print 888
-      
-    "
-
-    assert_equal(
-    "66.0
-1.0
-2.0
-Undefined variable c:
-
-      x = 1
-      y = 2
-      def foo(n)
-        return 2
-      end
-      foo(1)
-      
-      if x > y
-        print 999
-        print 777
-      else
-        print 66
-      end
-      
-      print x
-      print y
-      print 2*3+>>>c
-      print 888
-      
-    ", @driver.run(program))
-  end
-
-  def test_catches_undefined_functions
-    program = "
-
-      def foo(n)
-        bar(x)
-      end
-      
-      foo(2)
-      
-    "
-    assert_equal(
-    "Undefined function bar:
-
-
-      def foo(n)
-        >>>bar(x)
-      end
-      
-      foo(2)
-      
-    ", @driver.run(program))
-  end
-  # lipi:variable_scoping
-  def test_variable_scope
-    program = "
-      x = 1
-      
-      def bar(n)
-        print 999
-      end
-      
-      def foo(n)
-        bar(x)
-      end
-      
-      foo(2)
-      
-    "
-    assert_equal(
-    "Undefined variable x:
-
-      x = 1
-      
-      def bar(n)
-        print 999
-      end
-      
-      def foo(n)
-        bar(>>>x)
-      end
-      
-      foo(2)
-      
-    ", @driver.run(program))
-  end
-  # lipi:variable_scoping
-  
-  def test_nested_function_calls
-    
-    program = "
-    
-    def foo(a)
-      return a + 2
-    end
-    
-    def bar(b, c)
-      return b + c
-    end
-    
-    def baz(x, y, z)
-      return foo(y) + bar(x, z)
-    end
-    
-    print baz(foo(1), bar(2, 3), bar(6, 2))
-    
-    "
-    assert_equal("18.0", @driver.run(program))
-  end
-  
-  def test_wrong_number_of_arguments
-    
-    program = "
-    
-    def whatever(a, b)
-      return a + b
-    end
-    
-    whatever(1, 2, 3)
-    
-    "
-    assert_equal(
-    "Wrong number of arguments:
-
-    
-    def whatever(a, b)
-      return a + b
-    end
-    
-    whatever>>>(1, 2, 3)
-    
-    ", @driver.run(program))
-    
-  end
-
-  def test_an_empty_program
-    program = ""
-    assert_equal("Unexpected end of file.", @driver.run(program))
-  end
-
-  def test_associating_equality_tests_should_show_an_error
-    program = "
-    def foo()
-      print 999
-    end
-
-    foo()
-    print 1 == 1 == 1"
-    
-    assert_equal("Unexpected token ==:
-
-    def foo()
-      print 999
-    end
-
-    foo()
-    print 1 == 1 >>>== 1",  @driver.run(program))
-  end
-
-  def test_catches_bad_decimal_points
-    program = "
-    a = .234
-    c = 23.523
-    b = 20..2
-    "
-    
-    assert_equal("Unexpected character .:
-
-    a = .234
-    c = 23.523
-    b = 20.>>>.2
-    ",  @driver.run(program))
-  end
-  # lipi:recursive_fib
-  def test_recursive_fibonacci
-    program = "
-
-    def fib(n)
-      if n == 0
-        return 1
-      end
-      if n == 1
-        return 1
-      end
-      return fib(n-1) + fib(n-2)
-    end
-    
-    x = 0
-    while x < 9
-      print fib(x)
-      x = x + 1
-    end
-    
-    "
-    assert_equal(["1.0", "1.0", "2.0", "3.0", "5.0", "8.0", "13.0", "21.0", "34.0"].join("\n"), @driver.run(program))
-  end
-  # lipi:recursive_fib
-end

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

@@ -1,284 +0,0 @@
-require File.dirname(__FILE__) + '/chittagong_grammar'
-
-class ChittagongEvaluator < Dhaka::Evaluator
-
-  self.grammar = ChittagongGrammar
-
-  define_evaluation_rules do
-    
-    # No-ops
-    ['no_terms', 'multiple_terms', 'single_term', 'some_terms'].each {|production_name| eval("for_#{production_name} do end")}
-
-    for_program do
-      evaluate(child_nodes[1])
-    end
-
-    for_multiple_main_body_statements do
-      first = evaluate(child_nodes[0])
-      return first if first.exception
-      evaluate(child_nodes[2])
-    end  
-
-    for_multiple_function_body_statements do
-      first = evaluate(child_nodes[0])
-      return first if (first.exception || first.result)
-      evaluate(child_nodes[2])
-    end
-    # lipi:function_defs
-    for_function_definition do
-      function_name    = evaluate(child_nodes[1])
-      arg_declarations = evaluate(child_nodes[3])
-      body             = child_nodes[6]
-      @function_table[function_name] = Function.new(arg_declarations, body)
-      ChittagongSuccessResult.new(nil)
-    end
-    # lipi:function_defs
-
-    for_main_body_if_statement do
-      checked_if_statement
-    end
-    
-    for_function_body_if_statement do
-      checked_if_statement
-    end
-
-    def checked_if_statement
-      condition_eval = evaluate(child_nodes[1])
-      return condition_eval if condition_eval.exception
-      return evaluate(child_nodes[3]) if condition_eval.result
-      ChittagongSuccessResult.new(nil)
-    end
-    
-    for_main_body_if_else_statement do
-      checked_if_else_statement
-    end
-
-    for_function_body_if_else_statement do
-      checked_if_else_statement
-    end
-    
-    def checked_if_else_statement
-      condition_eval = evaluate(child_nodes[1])
-      return condition_eval if condition_eval.exception
-      if condition_eval.result
-        evaluate(child_nodes[3])
-      else
-        evaluate(child_nodes[7])
-      end
-    end
-
-    for_main_body_while_statement do
-      checked_while_statement
-    end
-    
-    for_function_body_while_statement do
-      checked_while_statement
-    end 
-    
-    def checked_while_statement
-      loop do
-        condition_eval = evaluate(child_nodes[1])
-        return condition_eval if condition_eval.exception
-        break unless condition_eval.result
-        body_eval = evaluate(child_nodes[3])
-        return body_eval if (body_eval.exception || body_eval.result)
-      end
-      ChittagongSuccessResult.new(nil)
-    end
-
-    for_assignment_statement do
-      rhs = evaluate(child_nodes[2])
-      return rhs if rhs.exception
-      @stack[-1][evaluate(child_nodes[0])] = rhs.result
-      ChittagongSuccessResult.new(nil)
-    end
-    
-    for_print_statement do
-      rhs = evaluate(child_nodes[1])
-      return rhs if rhs.exception
-      @output_stream << rhs.result.to_s
-      ChittagongSuccessResult.new(nil)
-    end
-
-    for_function_call_statement do
-      checked_function_call
-    end
-    
-    for_function_call_expression do
-      checked_function_call
-    end
-    # lipi:checked_function_call
-    def checked_function_call
-      function_name = evaluate(child_nodes[0])
-      return ChittagongExceptionResult.new("Undefined function #{function_name}", 
-          child_nodes[0]) unless @function_table.has_key?(function_name)
-      
-      arg_values = evaluate(child_nodes[2])
-      return arg_values if arg_values.exception
-      
-      function = @function_table[function_name]
-      return ChittagongExceptionResult.new(
-        "Wrong number of arguments", child_nodes[1]
-        ) unless function.args.size == arg_values.result.size
-      new_frame = {}
-      
-      function.args.zip(arg_values.result).each do |arg_name, arg_value|
-        new_frame[arg_name] = arg_value 
-      end
-      
-      @stack << new_frame
-      result = evaluate(function.body)
-      @stack.pop
-      
-      result
-    end
-    # lipi:checked_function_call
-    
-    for_return_statement do 
-      checked_unary_operation(child_nodes[1]){|x| x}
-    end
-    
-    for_single_arg_declaration do
-      [evaluate(child_nodes[0])]
-    end
-    
-    for_no_arg_decl do
-      []
-    end
-    
-    for_multiple_arg_declarations do 
-      evaluate(child_nodes[0]) + [evaluate(child_nodes[2])]
-    end
-    
-    for_no_args do
-      ChittagongSuccessResult.new([])
-    end
-    
-    for_single_arg do
-      checked_unary_operation(child_nodes[0]) {|x| [x]}
-    end
-    
-    for_multiple_args do
-      checked_binary_operation(child_nodes[0], child_nodes[2]) {|a, b| a + [b]}
-    end
-    
-    for_variable_reference do
-      variable_name = evaluate(child_nodes[0])
-      return ChittagongExceptionResult.new("Undefined variable #{variable_name}", child_nodes[0]) unless @stack[-1].has_key? variable_name
-      ChittagongSuccessResult.new(@stack[-1][variable_name])
-    end
-
-    for_subtraction do 
-      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a - b}
-    end
-
-    for_addition do
-      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a + b}
-    end
-
-    for_division do
-      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a.to_f / b}
-    end
-
-    for_multiplication do
-      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a * b}
-    end
-    
-    for_power do
-      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a ** b}
-    end
-    
-    for_less_than_comparison do
-      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a < b}
-    end
-
-    for_greater_than_comparison do
-      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a > b}
-    end
-
-    for_equality_comparison do
-      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a == b}
-    end
-        
-    def checked_binary_operation node1, node2
-      node1_eval = evaluate(node1)
-      node2_eval = evaluate(node2)
-      return node1_eval if node1_eval.exception
-      return node2_eval if node2_eval.exception
-      ChittagongSuccessResult.new(yield(node1_eval.result, node2_eval.result))
-    end
-
-    for_negated_expression do
-      checked_unary_operation(child_nodes[1]){|x| -x}
-    end
-
-    for_negation do
-      checked_unary_operation(child_nodes[1]){|b| !b}
-    end
-
-    for_parenthetized_expression do
-      checked_unary_operation(child_nodes[1]){|x| x}
-    end
-    
-    def checked_unary_operation node
-      node_eval = evaluate(node)
-      return node_eval if node_eval.exception
-      ChittagongSuccessResult.new(yield(node_eval.result))
-    end
-    
-    for_function_name do
-      token_value
-    end
-    
-    for_variable_name do
-      token_value
-    end
-    
-    for_arg_declaration do
-      token_value
-    end
-    
-    for_literal do
-      ChittagongSuccessResult.new(token_value.to_f)
-    end
-
-    def token_value
-      child_nodes.first.token.value
-    end
-    # lipi:initialize
-    def initialize(stack, output_stream)
-      @stack          = stack
-      @function_table = {}
-      @output_stream  = output_stream
-    end
-    # lipi:initialize
-  end
-
-end
-
-class ChittagongResult
-  attr_reader :exception
-end
-
-class ChittagongSuccessResult < ChittagongResult
-  attr_reader :result
-  def initialize(result)
-    @result = result
-  end
-end
-
-class ChittagongExceptionResult < ChittagongResult
-  attr_reader :node
-  def initialize(exception, node)
-    @exception = exception
-    @node      = node
-  end
-end
-
-class Function
-  attr_reader :args, :body
-  def initialize(args, body)
-    @args = args
-    @body = body
-  end
-end

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

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__) + '/../dhaka_test_helper'
-require File.dirname(__FILE__) + "/chittagong_evaluator"
-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 TestChittagongEvaluator < Test::Unit::TestCase
-  def test_evaluates_a_simple_program
-    token_stream  = build_tokens(
-      ['newline'],
-      ['word_literal', 'x'], ['='], ['numeric_literal', 23], ['newline'],
-      ['print'], ['word_literal', 'x'], ['newline'],
-      ['newline'],
-      ['word_literal', 'y'], ['='], ['word_literal', 'x'], ['+'], ['word_literal', 'x'], ['newline'],
-      ['print'], ['word_literal', 'y'], ['*'], ['word_literal', 'x'], ['newline'],
-      ['if'], ['word_literal', 'x'], ['>'], ['word_literal', 'y'], ['newline'],
-      ['print'], ['word_literal', 'x'], ['newline'],
-      ['else'], ['newline'],
-      ['print'], ['word_literal', 'y'], ['newline'],
-      ['end'], ['newline'],
-      ['newline'],
-      [Dhaka::END_SYMBOL_NAME]
-    )
-    stack         = [{}]
-    output_stream = []
-    ChittagongEvaluator.new(stack, output_stream).evaluate(ChittagongParser.parse(token_stream))
-    assert_equal(23, stack[0]['x'])
-    assert_equal(46, stack[0]['y'])
-    assert_equal(["23.0", "1058.0", "46.0"], output_stream)
-  end
-  
-  def build_tokens *tokens
-    tokens.collect {|token| Dhaka::Token.new(token[0], token[1], nil)}
-  end
-end

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

@@ -1,104 +0,0 @@
-class ChittagongGrammar < Dhaka::Grammar
-
-  precedences do
-    nonassoc %w| == |
-    nonassoc %w| < > |
-    left     %w| + - |
-    left     %w| * / |
-    nonassoc %w| ^ |
-    nonassoc %w| ! |
-  end
-  # lipi:grammar_overview
-  
-  for_symbol(Dhaka::START_SYMBOL_NAME) do
-    program                             %w| opt_terms main_body opt_terms |
-  end
-
-  for_symbol('main_body') do
-    single_main_body_statement          %w| main_body_statement |
-    multiple_main_body_statements       %w| main_body terms main_body_statement |
-  end
-  
-  for_symbol('main_body_statement') do
-    main_body_simple_statement          %w| simple_statement |
-    function_definition                 %w| def function_name ( arg_declarations ) terms 
-                                                function_body terms end |
-    main_body_if_statement              %w| if expression terms main_body terms end |
-    main_body_if_else_statement         %w| if expression terms main_body terms else terms main_body 
-                                                terms end |
-    main_body_while_statement           %w| while expression terms main_body terms end |
-  end
-  # lipi:grammar_overview
-
-  for_symbol('simple_statement') do
-    assignment_statement                %w| var_name = expression |
-    print_statement                     %w| print expression |
-    function_call_statement             %w| function_name ( arg_list ) |
-  end
-  
-  for_symbol('function_body') do
-    single_function_body_statement      %w| function_body_statement |
-    multiple_function_body_statements   %w| function_body terms function_body_statement |
-  end
-  
-  for_symbol('function_body_statement') do
-    function_body_simple_statement      %w| simple_statement |
-    return_statement                    %w| return expression |
-    function_body_if_statement          %w| if expression terms function_body terms end |
-    function_body_if_else_statement     %w| if expression terms function_body terms else terms function_body terms end |
-    function_body_while_statement       %w| while expression terms function_body terms end |
-  end
-  
-  for_symbol('function_name') do
-    function_name                       %w| word_literal |
-  end
-  
-  for_symbol('var_name') do
-    variable_name                       %w| word_literal |
-  end
-  
-  for_symbol('arg_declarations') do
-    no_arg_decl                         %w| |
-    single_arg_declaration              %w| arg_decl |
-    multiple_arg_declarations           %w| arg_declarations , arg_decl |
-  end
-  
-  for_symbol('arg_decl') do
-    arg_declaration                     %w| word_literal |
-  end
-  
-  for_symbol('arg_list') do
-    no_args                             %w| |
-    single_arg                          %w| expression |
-    multiple_args                       %w| arg_list , expression |
-  end
-  # lipi:expressions
-  for_symbol('expression') do
-    negation                            %w| ! expression |
-    equality_comparison                 %w| expression == expression |
-    greater_than_comparison             %w| expression > expression |
-    less_than_comparison                %w| expression < expression |
-    addition                            %w| expression + expression |
-    subtraction                         %w| expression - expression |
-    multiplication                      %w| expression * expression |
-    division                            %w| expression / expression |
-    power                               %w| expression ^ expression |
-    literal                             %w| numeric_literal |
-    function_call_expression            %w| function_name ( arg_list ) |
-    variable_reference                  %w| var_name |
-    parenthetized_expression            %w| ( expression ) |
-    negated_expression                  %w| - expression |, :prec => '*'
-  end
-  # lipi:expressions
-  
-  for_symbol('terms') do
-    single_term                         %w| newline |
-    multiple_terms                      %w| terms newline |
-  end
-
-  for_symbol('opt_terms') do
-    some_terms                          %w| terms |
-    no_terms                            %w| |
-  end
-  
-end