simply_stored 0.3.9 → 0.5.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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