simply_stored 0.1.4

data/test/vendor/dhaka-2.2.1/test/arithmetic/arithmetic_evaluator_test.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + '/arithmetic_evaluator'
+require File.dirname(__FILE__) + '/arithmetic_test_methods'
+eval(Dhaka::Parser.new(ArithmeticGrammar).compile_to_ruby_source_as(:CompiledArithmeticParser))
+
+class TestArithmeticEvaluator < Test::Unit::TestCase
+  include ArithmeticTestMethods
+  
+  def setup
+    @min_func = Proc.new {|args| args.inject {|min, elem| min = (elem < min ? elem : min)}}
+    @max_func = Proc.new {|args| args.inject {|max, elem| max = (elem > max ? elem : max)}}
+  end
+
+  def test_results_simple_arithmetic_given_tokens_and_parse_tree_1
+    token_stream = [token('n', 2), token('-', nil), token('n', 4), token(Dhaka::END_SYMBOL_NAME, nil)]
+    parse_tree   = parse(token_stream)
+    assert_equal -2, ArithmeticEvaluator.new(@min_func, @max_func).evaluate(parse_tree)
+  end
+
+  def test_results_simple_arithmetic_given_tokens_and_parse_tree_2
+    token_stream = [token('n', 2), token('-', nil), token('(', nil), token('n', 3), token('/', nil), token('n', 4), token(')', nil), token(Dhaka::END_SYMBOL_NAME, nil)]
+    parse_tree   = parse(token_stream)
+    assert_equal 1.25, ArithmeticEvaluator.new(@min_func, @max_func).evaluate(parse_tree)
+  end
+
+  def test_results_simple_arithmetic_given_tokens_and_parse_tree_3
+    token_stream = [token('n', 2), token('+', nil), token('(', nil), token('n', 3), token('/', nil), token('(', nil), token('n', 7), token('-', nil), token('n', 5), token(')', nil) , token(')', nil), token(Dhaka::END_SYMBOL_NAME, nil)]
+    parse_tree   = parse(token_stream)
+    assert_equal 3.5, ArithmeticEvaluator.new(@min_func, @max_func).evaluate(parse_tree)
+  end
+
+  def test_results_simple_arithmetic_given_tokens_and_parse_tree_4
+    token_stream = [token('n', 2), token('+', nil), token('h', nil), token('(', nil), token('n', 3), token(',', nil), token('n', 4), token(')', nil), token(Dhaka::END_SYMBOL_NAME, nil)]
+    parse_tree   = parse(token_stream)
+    assert_equal 6, ArithmeticEvaluator.new(@min_func, @max_func).evaluate(parse_tree)
+  end
+
+  def test_results_simple_arithmetic_given_tokens_and_parse_tree_5
+    token_stream = [token('n', 2), token('+', nil), token('l', nil), token('(', nil), token('n', 3), token(',', nil), token('n', 4), token(')', nil), token(Dhaka::END_SYMBOL_NAME, nil)]
+    parse_tree   = parse(token_stream)
+    assert_equal 5, ArithmeticEvaluator.new(@min_func, @max_func).evaluate(parse_tree)
+  end
+end

data/test/vendor/dhaka-2.2.1/test/arithmetic/arithmetic_grammar.rb

@@ -0,0 +1,41 @@
+class ArithmeticGrammar < Dhaka::Grammar
+
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    expression                         %w| E |
+  end
+
+  for_symbol('E') do
+    subtraction                        %w| E - T |
+    addition                           %w| E + T |
+    term                               %w| T |
+  end
+
+  for_symbol('T') do
+    factor                             %w| F |
+    division                           %w| T / F |
+    multiplication                     %w| T * F |
+  end
+
+  for_symbol('F') do
+    getting_literals                   %w| n |
+    unpacking_parenthetized_expression %w| ( E ) |
+    function                           %w| Function |
+  end
+
+  for_symbol('Function') do
+    evaluating_function                %w| FunctionName ( Args ) |
+  end
+
+  for_symbol('FunctionName') do
+    max_function                       %w| h |
+    min_function                       %w| l |
+  end
+
+  for_symbol('Args') do
+    empty_args                         %w||
+    single_args                        %w| E |
+    concatenating_args                 %w| E , Args |
+  end
+
+end
+

data/test/vendor/dhaka-2.2.1/test/arithmetic/arithmetic_grammar_test.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + '/arithmetic_grammar'
+
+class ArithmeticGrammarTest < Test::Unit::TestCase
+  def test_first_with_nullable_non_terminals
+    grammar = ArithmeticGrammar
+    assert_equal(Set.new(['(', 'n', 'h', 'l']), Set.new(grammar.first(grammar.symbol_for_name('Args')).collect { |symbol| symbol.name }))
+  end
+end

data/test/vendor/dhaka-2.2.1/test/arithmetic/arithmetic_test_methods.rb

@@ -0,0 +1,9 @@
+module ArithmeticTestMethods
+  def parse(token_stream)
+    CompiledArithmeticParser.parse(token_stream)
+  end
+  
+  def token(symbol_name, value)
+    Dhaka::Token.new(symbol_name, value, nil)
+  end
+end

data/test/vendor/dhaka-2.2.1/test/arithmetic/arithmetic_tokenizer.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/arithmetic_grammar'
+
+class ArithmeticTokenizer < Dhaka::Tokenizer
+  
+  digits        = ('0'..'9').to_a
+  parenths      = %w| ( ) |
+  operators     = %w| - + / * |
+  functions     = %w| h l |
+  arg_separator = %w| , |
+  whitespace    = [' ']
+
+  all_characters = digits + parenths + operators + functions + arg_separator + whitespace
+
+  for_state Dhaka::TOKENIZER_IDLE_STATE do
+    for_characters(all_characters - (digits + whitespace)) do
+      create_token(curr_char, nil)
+      advance
+    end
+    for_characters digits do
+      create_token('n', '')
+      switch_to :get_integer_literal
+    end
+    for_character whitespace do
+      advance
+    end
+  end
+  
+  for_state :get_integer_literal do
+    for_characters all_characters - digits do
+      switch_to Dhaka::TOKENIZER_IDLE_STATE
+    end
+    for_characters digits do
+      curr_token.value << curr_char
+      advance
+    end
+  end
+  
+end
+

data/test/vendor/dhaka-2.2.1/test/arithmetic/arithmetic_tokenizer_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/arithmetic_tokenizer"
+
+class TestArithmeticTokenizer < Test::Unit::TestCase
+  def test_returns_end_of_input_token_for_empty_input
+    assert_equal([token(Dhaka::END_SYMBOL_NAME, nil)], ArithmeticTokenizer.tokenize([]).to_a)
+  end
+  
+  def test_tokenizes_given_a_string_input
+    assert_equal([token('n', 2), token('-', nil), token('n', 4), token(Dhaka::END_SYMBOL_NAME, nil)], ArithmeticTokenizer.tokenize('2 - 4').to_a) 
+  end
+  
+  def test_a_longer_input
+    actual = ArithmeticTokenizer.tokenize('2+(3 / (7 - 5))').to_a
+    assert_equal([token('n', 2), token('+', nil), token('(', nil), token('n', 3), token('/', nil), token('(', nil), token('n', 7), token('-', nil), token('n', 5), token(')', nil) , token(')', nil), token(Dhaka::END_SYMBOL_NAME, nil)], actual)
+  end
+
+  def test_another_input_with_multi_digit_numbers
+    actual = ArithmeticTokenizer.tokenize('2034 +(3433 / (7 - 5))').to_a
+    assert_equal([token('n', 2034), token('+', nil), token('(', nil), token('n', 3433), token('/', nil), token('(', nil), token('n', 7), token('-', nil), token('n', 5), token(')', nil) , token(')', nil), token(Dhaka::END_SYMBOL_NAME, nil)], actual)
+  end
+
+  def test_an_input_with_unrecognized_characters
+    result = ArithmeticTokenizer.tokenize('2+(3 / (7 -& 5))')
+    assert(result.has_error?)
+    assert_equal(11, result.unexpected_char_index)
+  end
+
+  def test_another_input_with_illegal_characters
+    result = ArithmeticTokenizer.tokenize('2034 +(34b3 / (7 - 5))')
+    assert(result.has_error?)
+    assert_equal(9, result.unexpected_char_index)
+  end
+
+  def token(symbol_name, value)
+    Dhaka::Token.new(symbol_name, value ? value.to_s : nil, nil)
+  end
+end

data/test/vendor/dhaka-2.2.1/test/arithmetic_precedence/arithmetic_precedence_evaluator.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/arithmetic_precedence_grammar'
+
+class ArithmeticPrecedenceEvaluator < Dhaka::Evaluator
+  
+  self.grammar = ArithmeticPrecedenceGrammar
+  
+  define_evaluation_rules do
+    
+    for_subtraction do 
+      evaluate(child_nodes[0]) - evaluate(child_nodes[2])
+    end
+
+    for_addition do
+      evaluate(child_nodes[0]) + evaluate(child_nodes[2])
+    end
+
+    for_division do
+      evaluate(child_nodes[0]).to_f/evaluate(child_nodes[2]) 
+    end
+
+    for_multiplication do
+      evaluate(child_nodes[0]) * evaluate(child_nodes[2])
+    end
+
+    for_literal do
+      child_nodes[0].token.value.to_i
+    end
+
+    for_parenthetized_expression do
+      evaluate(child_nodes[1])
+    end
+    
+    for_negated_expression do
+      -evaluate(child_nodes[1])
+    end
+    
+    for_power do
+      evaluate(child_nodes[0])**evaluate(child_nodes[2])
+    end
+
+  end
+
+end

data/test/vendor/dhaka-2.2.1/test/arithmetic_precedence/arithmetic_precedence_grammar.rb

@@ -0,0 +1,24 @@
+class ArithmeticPrecedenceGrammar < Dhaka::Grammar
+
+  precedences do
+    left                     %w| + - |
+    left                     %w| * / |
+    nonassoc                 %w| ^ |
+  end
+  
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    expression               %w| E |
+  end
+  
+  for_symbol('E') do
+    addition                 %w| E + E |
+    subtraction              %w| E - E |
+    multiplication           %w| E * E |
+    division                 %w| E / E |
+    power                    %w| E ^ E |
+    literal                  %w| n |
+    parenthetized_expression %w| ( E ) |
+    negated_expression       %w| - E |, :prec => '*'
+  end
+
+end

data/test/vendor/dhaka-2.2.1/test/arithmetic_precedence/arithmetic_precedence_grammar_test.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + '/arithmetic_precedence_grammar'
+
+class TestArithmeticPrecedenceGrammar < Test::Unit::TestCase
+  def setup
+    @addop = ArithmeticPrecedenceGrammar.symbol_for_name('+')
+    @subop = ArithmeticPrecedenceGrammar.symbol_for_name('-')
+    @mulop = ArithmeticPrecedenceGrammar.symbol_for_name('*')
+    @divop = ArithmeticPrecedenceGrammar.symbol_for_name('/')
+    @powop = ArithmeticPrecedenceGrammar.symbol_for_name('^')
+  end
+  
+  def test_precedence_levels_and_associativity_of_terminals
+    assert_equal(0, @addop.precedence.precedence_level)
+    assert_equal(0, @subop.precedence.precedence_level)
+    assert_equal(1, @mulop.precedence.precedence_level)
+    assert_equal(1, @divop.precedence.precedence_level)
+    assert_equal(2, @powop.precedence.precedence_level)
+    assert_equal(:left, @addop.precedence.associativity)
+    assert_equal(:left, @subop.precedence.associativity)
+    assert_equal(:left, @mulop.precedence.associativity)
+    assert_equal(:left, @divop.precedence.associativity)
+    assert_equal(:nonassoc, @powop.precedence.associativity)
+  end
+  def test_precedence_of_production
+    assert_equal(@addop.precedence, ArithmeticPrecedenceGrammar.production_named("addition").precedence)
+    assert_equal(@mulop.precedence, ArithmeticPrecedenceGrammar.production_named("multiplication").precedence)
+    assert_equal(@mulop.precedence, ArithmeticPrecedenceGrammar.production_named("negated_expression").precedence)
+  end
+end

data/test/vendor/dhaka-2.2.1/test/arithmetic_precedence/arithmetic_precedence_lexer_specification.rb

@@ -0,0 +1,23 @@
+class ArithmeticPrecedenceLexerSpecification < Dhaka::LexerSpecification
+  
+  for_pattern '\s' do
+    # ignore whitespace
+  end
+  
+  %w| - h l , |.each do |char|
+    for_pattern char do
+      create_token(char)
+    end
+  end
+  
+  %w| ( ) + / * ^ |.each do |char|
+    for_pattern "\\#{char}" do
+      create_token(char)
+    end
+  end
+  
+  for_pattern '\d+' do
+    create_token('n')
+  end
+
+end

data/test/vendor/dhaka-2.2.1/test/arithmetic_precedence/arithmetic_precedence_parser_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/arithmetic_precedence_grammar"
+require File.dirname(__FILE__) + "/arithmetic_precedence_lexer_specification"
+require File.dirname(__FILE__) + "/arithmetic_precedence_evaluator"
+
+class TestArithmeticPrecedenceParser < Test::Unit::TestCase
+  def test_parses_arithmetic_expressions
+    fake_logger = FakeLogger.new
+    parser      = Dhaka::Parser.new(ArithmeticPrecedenceGrammar, fake_logger)
+    lexer       = Dhaka::Lexer.new(ArithmeticPrecedenceLexerSpecification)
+    eval(parser.compile_to_ruby_source_as(:ArithmeticPrecedenceParser))
+    eval(lexer.compile_to_ruby_source_as(:ArithmeticPrecedenceLexer))
+
+    assert_equal(30, fake_logger.warnings.size)
+    assert_equal(0, fake_logger.errors.size)
+    
+    assert_equal(-8, evaluate(parse("5 * -14/(2*7 - 7) + 2")))
+    assert_equal(-4, evaluate(parse("-2^2")))
+    assert_equal(10, evaluate(parse("2+2^3")))
+    assert_equal(64, evaluate(parse("(2+2)^3")))
+    assert_equal(128, evaluate(parse("(2+2)^3*2")))
+    assert(parse("(2+2)^3^2").has_error?)
+  end
+  
+  def parse(input)
+    ArithmeticPrecedenceParser.parse(ArithmeticPrecedenceLexer.lex(input))
+  end
+
+  def evaluate(parse_tree)
+    ArithmeticPrecedenceEvaluator.new.evaluate(parse_tree)
+  end
+end
+

data/test/vendor/dhaka-2.2.1/test/brackets/bracket_grammar.rb

@@ -0,0 +1,23 @@
+class BracketGrammar < Dhaka::Grammar
+  
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    start                %w| Package |
+  end
+  
+  for_symbol('Package') do
+    soft_wrapped_package %w| ( Contents ) |
+    cardboard_package    %w| [ Contents ] |
+    wooden_package       %w| { Contents } |
+  end
+  
+  for_symbol('Contents') do
+    bracket              %w| B |
+    set_of_packages      %w| SetOfPackages |
+  end
+    
+  for_symbol('SetOfPackages') do
+    one_package          %w| Package |
+    multiple_packages    %w| SetOfPackages Package |
+  end
+
+end

data/test/vendor/dhaka-2.2.1/test/brackets/bracket_tokenizer.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/bracket_grammar'
+
+class BracketTokenizer < Dhaka::Tokenizer
+  
+  all_characters = %w| ( [ { B } ] ) |
+
+  for_state Dhaka::TOKENIZER_IDLE_STATE do
+    for_characters(all_characters) do
+      create_token(curr_char, nil)
+      advance
+    end
+  end
+  
+end
+
+class LazyBracketTokenizer < BracketTokenizer
+  for_state Dhaka::TOKENIZER_IDLE_STATE do
+    for_default do
+      advance
+    end
+  end
+end

data/test/vendor/dhaka-2.2.1/test/brackets/brackets_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/bracket_grammar"
+require File.dirname(__FILE__) + '/bracket_tokenizer'
+
+class TestBracketGrammar < Test::Unit::TestCase
+  def test_recognizes_faulty_bracket_configuration_correctly
+    eval Dhaka::Parser.new(BracketGrammar).compile_to_ruby_source_as(:BracketParser)
+    assert correct("[{(B)[B]}(B)]")
+    assert correct("[[B]{(B)}(B)]")
+    assert correct("{(B)[B]}")
+    assert !correct("{B[B]}")
+    assert !correct("B")
+    assert !correct("[[B]{(B)}}(B)]")
+  end
+  
+  def test_ignores_invalid_characters_with_default_action
+    tokens = BracketTokenizer.tokenize("A{(B)[B]}")
+    assert tokens.has_error?
+    
+    tokens = LazyBracketTokenizer.tokenize("A{(B)[B]}")
+    assert !tokens.has_error?
+  end
+  
+  def correct input_string
+    result = BracketParser.parse(BracketTokenizer.tokenize(input_string))
+    !result.has_error?
+  end
+end

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

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + "/chittagong_lexer_specification"
+require File.dirname(__FILE__) + "/chittagong_evaluator"
+
+class ChittagongDriver
+
+  ERROR_MARKER = ">>>"
+  
+  def parse_error_message unexpected_token, program
+    if unexpected_token.symbol_name == Dhaka::END_SYMBOL_NAME
+      "Unexpected end of file."
+    else
+      "Unexpected token #{unexpected_token.symbol_name}:\n#{program.dup.insert(unexpected_token.input_position, ERROR_MARKER)}"
+    end
+  end
+  
+  def tokenize_error_message unexpected_char_index, program
+    "Unexpected character #{program[unexpected_char_index].chr}:\n#{program.dup.insert(unexpected_char_index, ERROR_MARKER)}"
+  end
+  
+  def evaluation_error_message evaluation_result, program
+    "#{evaluation_result.exception}:\n#{program.dup.insert(evaluation_result.node.tokens[0].input_position, ERROR_MARKER)}"
+  end
+  
+  # lipi:run_method
+  def run(program)
+    parse_result = ChittagongParser.parse(ChittagongLexer.lex(program))
+
+    case parse_result
+      when Dhaka::TokenizerErrorResult
+        return tokenize_error_message(parse_result.unexpected_char_index, program)
+      when Dhaka::ParseErrorResult
+        return parse_error_message(parse_result.unexpected_token, program) 
+    end
+    
+    evaluation_result = ChittagongEvaluator.new([{}], output_stream = []).
+        evaluate(parse_result)
+    if evaluation_result.exception
+      return (output_stream << evaluation_error_message(evaluation_result, program)).
+        join("\n") 
+    end
+    
+    return output_stream.join("\n")
+  end
+  # lipi:run_method
+  
+end