dhaka 0.0.1

data/test/arithmetic_evaluator_test.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+require 'compiled_arithmetic_parser'
+require 'arithmetic_evaluator'
+require 'arithmetic_test_methods'
+
+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_syntax_tree_1
+    
+    token_stream = [token('n', 2), token('-', nil), token('n', 4), token('#', nil)]
+    syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+    assert_equal -2, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
+    
+  end
+
+  def test_results_simple_arithmetic_given_tokens_and_syntax_tree_2
+
+    token_stream = [token('n', 2), token('-', nil), token('(', nil), token('n', 3), token('/', nil), token('n', 4), token(')', nil), token('#', nil)]
+    syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+    assert_equal 1.25, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
+
+  end
+
+  def test_results_simple_arithmetic_given_tokens_and_syntax_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('#', nil)]
+    syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+    assert_equal 3.5, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
+
+  end
+
+  def test_results_simple_arithmetic_given_tokens_and_syntax_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('#', nil)]
+    syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+    assert_equal 6, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
+
+  end
+
+  def test_results_simple_arithmetic_given_tokens_and_syntax_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('#', nil)]
+    syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+    assert_equal 5, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
+
+  end
+
+end

data/test/arithmetic_grammar.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__)+'/../lib/dhaka'
+
+class ArithmeticGrammar < Dhaka::Grammar
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    start_production ['S', '#']
+  end
+  for_symbol('S') do
+    expression ['E']
+  end
+  for_symbol('E') do
+    subtraction ['E', '-', 'T']
+    addition ['E', '+', 'T']
+    term ['T']
+  end
+  for_symbol('T') do
+    factor ['F']
+    division ['T', '/', 'F']
+    multiplication ['T', '*', 'F']
+  end
+  for_symbol('F') do
+    getting_literals ['n']
+    unpacking_parenthetized_expression ['(', 'E', ')']
+    function ['Function']
+  end
+  for_symbol('Function') do
+    evaluating_function ['FunctionName', '(', 'Args', ')']
+  end
+  for_symbol('FunctionName') do
+    max_function ['h']
+    min_function ['l']
+  end
+  for_symbol('Args') do
+    empty_args []
+    single_args ['E']
+    concatenating_args ['E', ',', 'Args']
+  end
+end
+

data/test/arithmetic_grammar_test.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require '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/arithmetic_test_methods.rb

@@ -0,0 +1,11 @@
+module ArithmeticTestMethods
+  
+  def get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+    CompiledArithmeticParser.parse(token_stream).syntax_tree
+  end
+  
+  def token(symbol_name, value)
+    Dhaka::Token.new(CompiledArithmeticParser.grammar.symbol_for_name(symbol_name), value)
+  end
+  
+end

data/test/arithmetic_tokenizer.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__)+'/../lib/dhaka'
+require 'arithmetic_grammar'
+
+
+class ArithmeticTokenizer < Dhaka::Tokenizer
+  
+  digits = ('0'..'9').to_a
+  parenths = ['(', ')']
+  operators = ['-', '+', '/', '*']
+  functions = ['h', 'l']
+  arg_separator = [',']
+  sentinel = ['#']
+  whitespace = [' ']
+
+  all_characters = digits + parenths + operators + functions + arg_separator + sentinel + whitespace
+
+  for_state :idle_state do
+    for_characters(all_characters - (digits + whitespace)) do
+      tokens << Dhaka::Token.new(ArithmeticGrammar.symbol_for_name(curr_char), nil)
+      advance
+    end
+    for_characters digits do
+      self.accumulator = ''
+      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
+      tokens << Dhaka::Token.new(ArithmeticGrammar.symbol_for_name('n'), accumulator.to_i)
+      switch_to :idle_state
+    end
+    for_characters digits do
+      self.accumulator += curr_char
+      advance
+    end
+  end
+  
+end
+

data/test/arithmetic_tokenizer_test.rb

@@ -0,0 +1,32 @@
+require "test/unit"
+require "arithmetic_tokenizer"
+
+class TestArithmeticTokenizer < Test::Unit::TestCase
+  def test_returns_empty_array_for_empty_input
+    assert_equal([], ArithmeticTokenizer.tokenize([]))
+  end
+  def test_tokenizes_given_a_string_input
+    assert_equal([token('n', 2), token('-', nil), token('n', 4), token('#', nil)], ArithmeticTokenizer.tokenize('2 - 4 #')) 
+  end
+  def test_a_longer_input
+    actual = ArithmeticTokenizer.tokenize('2+(3 / (7 - 5))#')
+    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('#', nil)], actual)
+  end
+
+  def test_another_input_with_multi_digit_numbers
+    actual = ArithmeticTokenizer.tokenize('2034 +(3433 / (7 - 5))#')
+    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('#', nil)], actual)
+  end
+
+  def test_an_input_with_unrecognized_characters
+    assert_raise(Dhaka::UnrecognizedInputCharacterException) {ArithmeticTokenizer.tokenize('2+(3 / (7 -& 5))#')}
+  end
+
+  def test_another_input_with_illegal_characters
+    assert_raise(Dhaka::UnrecognizedInputCharacterException) {ArithmeticTokenizer.tokenize('2034 +(34b3 / (7 - 5))#')}
+  end
+
+  def token(symbol_name, value)
+    Dhaka::Token.new(ArithmeticGrammar.symbol_for_name(symbol_name), value)
+  end
+end

data/test/bracket_grammar.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__)+'/../lib/dhaka'
+
+class BracketGrammar < Dhaka::Grammar
+  
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    start ['Package']
+  end
+  
+  for_symbol('Package') do
+    soft_wrapped_package ['(', 'Contents', ')']
+    cardboard_package ['[', 'Contents', ']']
+    wooden_package ['{', 'Contents', '}']
+  end
+  
+  for_symbol('Contents') do
+    bracket ['B']
+    set_of_packages ['SetOfPackages']
+  end
+    
+  for_symbol('SetOfPackages') do
+    one_package ['Package']
+    multiple_packages ['SetOfPackages', 'Package']
+  end
+
+end

data/test/bracket_tokenizer.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__)+'/../lib/dhaka'
+require 'bracket_grammar'
+
+
+class BracketTokenizer < Dhaka::Tokenizer
+  
+  all_characters = ['(', '[', '{', 'B', '}', ']', ')']
+
+  for_state :idle_state do
+    for_characters(all_characters) do
+      tokens << Dhaka::Token.new(BracketGrammar.symbol_for_name(curr_char), nil)
+      advance
+    end
+  end
+  
+end
+

data/test/brackets_test.rb

@@ -0,0 +1,20 @@
+require "test/unit"
+
+require "bracket_grammar"
+require '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 correct input_string
+    result = BracketParser.parse(BracketTokenizer.tokenize(input_string))
+    !result.has_error?
+  end
+end

data/test/compiled_arithmetic_parser.rb

@@ -0,0 +1,252 @@
+require File.dirname(__FILE__)+'/../lib/dhaka'
+require 'arithmetic_grammar'
+
+class CompiledArithmeticParser < Dhaka::CompiledParser
+
+  self.grammar = ArithmeticGrammar
+
+  start_with 33
+
+  at_state(48) {
+    for_symbol('l') { shift_to 47 }
+    for_symbol('n') { shift_to 42 }
+    for_symbol('FunctionName') { shift_to 34 }
+    for_symbol('Function') { shift_to 46 }
+    for_symbol('F') { shift_to 49 }
+    for_symbol('h') { shift_to 41 }
+    for_symbol('(') { shift_to 38 }
+  }
+
+  at_state(43) {
+    for_symbol('+') { reduce_with 'subtraction' }
+    for_symbol(',') { reduce_with 'subtraction' }
+    for_symbol('-') { reduce_with 'subtraction' }
+    for_symbol('#') { reduce_with 'subtraction' }
+    for_symbol('/') { shift_to 44 }
+    for_symbol(')') { reduce_with 'subtraction' }
+    for_symbol('*') { shift_to 48 }
+  }
+
+  at_state(55) {
+    for_symbol('+') { shift_to 52 }
+    for_symbol(',') { shift_to 56 }
+    for_symbol('-') { shift_to 40 }
+    for_symbol(')') { reduce_with 'single_args' }
+  }
+
+  at_state(53) {
+    for_symbol('+') { reduce_with 'addition' }
+    for_symbol(',') { reduce_with 'addition' }
+    for_symbol('-') { reduce_with 'addition' }
+    for_symbol('#') { reduce_with 'addition' }
+    for_symbol('/') { shift_to 44 }
+    for_symbol(')') { reduce_with 'addition' }
+    for_symbol('*') { shift_to 48 }
+  }
+
+  at_state(50) {
+    for_symbol('+') { reduce_with 'factor' }
+    for_symbol(',') { reduce_with 'factor' }
+    for_symbol('-') { reduce_with 'factor' }
+    for_symbol('#') { reduce_with 'factor' }
+    for_symbol('/') { reduce_with 'factor' }
+    for_symbol(')') { reduce_with 'factor' }
+    for_symbol('*') { reduce_with 'factor' }
+  }
+
+  at_state(47) {
+    for_symbol('(') { reduce_with 'min_function' }
+  }
+
+  at_state(52) {
+    for_symbol('l') { shift_to 47 }
+    for_symbol('n') { shift_to 42 }
+    for_symbol('FunctionName') { shift_to 34 }
+    for_symbol('Function') { shift_to 46 }
+    for_symbol('F') { shift_to 50 }
+    for_symbol('h') { shift_to 41 }
+    for_symbol('(') { shift_to 38 }
+    for_symbol('T') { shift_to 53 }
+  }
+
+  at_state(33) {
+    for_symbol('l') { shift_to 47 }
+    for_symbol('n') { shift_to 42 }
+    for_symbol('FunctionName') { shift_to 34 }
+    for_symbol('E') { shift_to 58 }
+    for_symbol('Function') { shift_to 46 }
+    for_symbol('F') { shift_to 50 }
+    for_symbol('S') { shift_to 59 }
+    for_symbol('h') { shift_to 41 }
+    for_symbol('(') { shift_to 38 }
+    for_symbol('T') { shift_to 54 }
+  }
+
+  at_state(59) {
+    for_symbol('#') { shift_to 60 }
+  }
+
+  at_state(38) {
+    for_symbol('l') { shift_to 47 }
+    for_symbol('n') { shift_to 42 }
+    for_symbol('FunctionName') { shift_to 34 }
+    for_symbol('E') { shift_to 39 }
+    for_symbol('Function') { shift_to 46 }
+    for_symbol('F') { shift_to 50 }
+    for_symbol('h') { shift_to 41 }
+    for_symbol('(') { shift_to 38 }
+    for_symbol('T') { shift_to 54 }
+  }
+
+  at_state(34) {
+    for_symbol('(') { shift_to 35 }
+  }
+
+  at_state(41) {
+    for_symbol('(') { reduce_with 'max_function' }
+  }
+
+  at_state(60) {
+    for_symbol('_End_') { reduce_with 'start_production' }
+  }
+
+  at_state(46) {
+    for_symbol('+') { reduce_with 'function' }
+    for_symbol(',') { reduce_with 'function' }
+    for_symbol('-') { reduce_with 'function' }
+    for_symbol('#') { reduce_with 'function' }
+    for_symbol('/') { reduce_with 'function' }
+    for_symbol(')') { reduce_with 'function' }
+    for_symbol('*') { reduce_with 'function' }
+  }
+
+  at_state(45) {
+    for_symbol('+') { reduce_with 'division' }
+    for_symbol(',') { reduce_with 'division' }
+    for_symbol('-') { reduce_with 'division' }
+    for_symbol('#') { reduce_with 'division' }
+    for_symbol('/') { reduce_with 'division' }
+    for_symbol(')') { reduce_with 'division' }
+    for_symbol('*') { reduce_with 'division' }
+  }
+
+  at_state(35) {
+    for_symbol('l') { shift_to 47 }
+    for_symbol('n') { shift_to 42 }
+    for_symbol('FunctionName') { shift_to 34 }
+    for_symbol('E') { shift_to 55 }
+    for_symbol('Function') { shift_to 46 }
+    for_symbol('F') { shift_to 50 }
+    for_symbol('Args') { shift_to 36 }
+    for_symbol('h') { shift_to 41 }
+    for_symbol('(') { shift_to 38 }
+    for_symbol(')') { reduce_with 'empty_args' }
+    for_symbol('T') { shift_to 54 }
+  }
+
+  at_state(54) {
+    for_symbol('+') { reduce_with 'term' }
+    for_symbol(',') { reduce_with 'term' }
+    for_symbol('-') { reduce_with 'term' }
+    for_symbol('#') { reduce_with 'term' }
+    for_symbol('/') { shift_to 44 }
+    for_symbol(')') { reduce_with 'term' }
+    for_symbol('*') { shift_to 48 }
+  }
+
+  at_state(58) {
+    for_symbol('+') { shift_to 52 }
+    for_symbol('-') { shift_to 40 }
+    for_symbol('#') { reduce_with 'expression' }
+  }
+
+  at_state(56) {
+    for_symbol('l') { shift_to 47 }
+    for_symbol('n') { shift_to 42 }
+    for_symbol('FunctionName') { shift_to 34 }
+    for_symbol('E') { shift_to 55 }
+    for_symbol('Function') { shift_to 46 }
+    for_symbol('F') { shift_to 50 }
+    for_symbol('Args') { shift_to 57 }
+    for_symbol('h') { shift_to 41 }
+    for_symbol('(') { shift_to 38 }
+    for_symbol(')') { reduce_with 'empty_args' }
+    for_symbol('T') { shift_to 54 }
+  }
+
+  at_state(51) {
+    for_symbol('+') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol(',') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol('-') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol('#') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol('/') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol(')') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol('*') { reduce_with 'unpacking_parenthetized_expression' }
+  }
+
+  at_state(44) {
+    for_symbol('l') { shift_to 47 }
+    for_symbol('n') { shift_to 42 }
+    for_symbol('FunctionName') { shift_to 34 }
+    for_symbol('F') { shift_to 45 }
+    for_symbol('Function') { shift_to 46 }
+    for_symbol('h') { shift_to 41 }
+    for_symbol('(') { shift_to 38 }
+  }
+
+  at_state(42) {
+    for_symbol('+') { reduce_with 'getting_literals' }
+    for_symbol(',') { reduce_with 'getting_literals' }
+    for_symbol('-') { reduce_with 'getting_literals' }
+    for_symbol('#') { reduce_with 'getting_literals' }
+    for_symbol('/') { reduce_with 'getting_literals' }
+    for_symbol(')') { reduce_with 'getting_literals' }
+    for_symbol('*') { reduce_with 'getting_literals' }
+  }
+
+  at_state(36) {
+    for_symbol(')') { shift_to 37 }
+  }
+
+  at_state(49) {
+    for_symbol('+') { reduce_with 'multiplication' }
+    for_symbol(',') { reduce_with 'multiplication' }
+    for_symbol('-') { reduce_with 'multiplication' }
+    for_symbol('#') { reduce_with 'multiplication' }
+    for_symbol('/') { reduce_with 'multiplication' }
+    for_symbol(')') { reduce_with 'multiplication' }
+    for_symbol('*') { reduce_with 'multiplication' }
+  }
+
+  at_state(57) {
+    for_symbol(')') { reduce_with 'concatenating_args' }
+  }
+
+  at_state(40) {
+    for_symbol('l') { shift_to 47 }
+    for_symbol('n') { shift_to 42 }
+    for_symbol('FunctionName') { shift_to 34 }
+    for_symbol('Function') { shift_to 46 }
+    for_symbol('F') { shift_to 50 }
+    for_symbol('h') { shift_to 41 }
+    for_symbol('(') { shift_to 38 }
+    for_symbol('T') { shift_to 43 }
+  }
+
+  at_state(39) {
+    for_symbol('+') { shift_to 52 }
+    for_symbol('-') { shift_to 40 }
+    for_symbol(')') { shift_to 51 }
+  }
+
+  at_state(37) {
+    for_symbol('+') { reduce_with 'evaluating_function' }
+    for_symbol(',') { reduce_with 'evaluating_function' }
+    for_symbol('-') { reduce_with 'evaluating_function' }
+    for_symbol('#') { reduce_with 'evaluating_function' }
+    for_symbol('/') { reduce_with 'evaluating_function' }
+    for_symbol(')') { reduce_with 'evaluating_function' }
+    for_symbol('*') { reduce_with 'evaluating_function' }
+  }
+
+end