dhaka 2.0.0 → 2.0.1

data/test/all_tests.rb

@@ -1,19 +1,5 @@
 #!/usr/bin/env ruby
-require 'test/unit'
-require 'grammar_test'
-require 'malformed_grammar_test'
-require 'parser_test'
-require 'evaluator_test'
-require 'compiled_parser_test'
-require 'arithmetic_evaluator_test'
-require 'arithmetic_grammar_test'
-require 'arithmetic_tokenizer_test'
-require 'arithmetic_precedence_grammar_test'
-require 'arithmetic_precedence_parser_test'
-require 'brackets_test'
-require 'precedence_grammar_test'
-require 'chittagong_parser_test'
-require 'chittagong_evaluator_test'
-require 'chittagong_tokenizer_test'
-require 'chittagong_test'
-require 'chittagong_driver_test'
+Dir['**/*test.rb'].each do |test_file|
+  puts test_file
+  require File.join(File.dirname(__FILE__), test_file)
+end

data/test/another_lalr_but_not_slr_grammar.rb

@@ -1,16 +1,20 @@
 require File.dirname(__FILE__)+'/../lib/dhaka'
 
 class AnotherLALRButNotSLRGrammar < Dhaka::Grammar
+
   for_symbol(Dhaka::START_SYMBOL_NAME) do
-    assignment ['L', '=', 'R']
-    rhs ['R']
+    assignment %w| L = R |
+    rhs        %w| R |
   end
+
   for_symbol('L') do
-    contents ['*', 'R']
-    identifier ['id']
+    contents   %w| * R |
+    identifier %w| id |
   end
+
   for_symbol('R') do
-    l_value ['L']
+    l_value    %w| L |
   end
+
 end
 

data/test/{arithmetic_evaluator.rb → arithmetic/arithmetic_evaluator.rb}

@@ -1,5 +1,4 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-require 'arithmetic_grammar'
+require File.dirname(__FILE__) + '/arithmetic_grammar'
 
 class ArithmeticEvaluator < Dhaka::Evaluator
   

data/test/{arithmetic_evaluator_test.rb → arithmetic/arithmetic_evaluator_test.rb}

@@ -1,7 +1,8 @@
-require 'test/unit'
-require 'arithmetic_evaluator'
-require 'arithmetic_test_methods'
+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
   
@@ -10,45 +11,33 @@ class TestArithmeticEvaluator < Test::Unit::TestCase
     @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)
+    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)
+    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)
+    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)
+    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)
+    parse_tree   = parse(token_stream)
     assert_equal 5, ArithmeticEvaluator.new(@min_func, @max_func).evaluate(parse_tree)
-
   end
-
 end

data/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/{arithmetic_grammar_test.rb → arithmetic/arithmetic_grammar_test.rb}

@@ -1,11 +1,9 @@
-require 'test/unit'
-require 'arithmetic_grammar'
+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/{arithmetic_test_methods.rb → arithmetic/arithmetic_test_methods.rb}

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

data/test/{arithmetic_tokenizer.rb → arithmetic/arithmetic_tokenizer.rb}

@@ -1,15 +1,13 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-require 'arithmetic_grammar'
-
+require File.dirname(__FILE__) + '/arithmetic_grammar'
 
 class ArithmeticTokenizer < Dhaka::Tokenizer
   
-  digits = ('0'..'9').to_a
-  parenths = ['(', ')']
-  operators = ['-', '+', '/', '*']
-  functions = ['h', 'l']
-  arg_separator = [',']
-  whitespace = [' ']
+  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
 
@@ -32,7 +30,7 @@ class ArithmeticTokenizer < Dhaka::Tokenizer
       switch_to Dhaka::TOKENIZER_IDLE_STATE
     end
     for_characters digits do
-      curr_token.value += curr_char
+      curr_token.value << curr_char
       advance
     end
   end

data/test/{arithmetic_tokenizer_test.rb → arithmetic/arithmetic_tokenizer_test.rb}

@@ -1,13 +1,15 @@
-require "test/unit"
-require "arithmetic_tokenizer"
+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)

data/test/{arithmetic_precedence_evaluator.rb → arithmetic_precedence/arithmetic_precedence_evaluator.rb}

@@ -1,5 +1,4 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-require 'arithmetic_precedence_grammar'
+require File.dirname(__FILE__) + '/arithmetic_precedence_grammar'
 
 class ArithmeticPrecedenceEvaluator < Dhaka::Evaluator
   

data/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/{arithmetic_precedence_grammar_test.rb → arithmetic_precedence/arithmetic_precedence_grammar_test.rb}

@@ -1,8 +1,7 @@
-require "test/unit"
-require 'arithmetic_precedence_grammar'
+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('-')

data/test/arithmetic_precedence/arithmetic_precedence_parser_test.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/arithmetic_precedence_grammar"
+require File.dirname(__FILE__) + "/arithmetic_precedence_tokenizer"
+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)
+    eval(parser.compile_to_ruby_source_as(:ArithmeticPrecedenceParser))
+
+    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(ArithmeticPrecedenceTokenizer.tokenize(input))
+  end
+
+  def evaluate(parse_tree)
+    ArithmeticPrecedenceEvaluator.new.evaluate(parse_tree)
+  end
+end
+

data/test/{arithmetic_precedence_tokenizer.rb → arithmetic_precedence/arithmetic_precedence_tokenizer.rb}

@@ -1,15 +1,13 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-require 'arithmetic_precedence_grammar'
-
+require File.dirname(__FILE__) + '/arithmetic_precedence_grammar'
 
 class ArithmeticPrecedenceTokenizer < Dhaka::Tokenizer
   
-  digits = ('0'..'9').to_a
-  parenths = ['(', ')']
-  operators = ['-', '+', '/', '*', '^']
-  functions = ['h', 'l']
-  arg_separator = [',']
-  whitespace = [' ']
+  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
 
@@ -32,7 +30,7 @@ class ArithmeticPrecedenceTokenizer < Dhaka::Tokenizer
       switch_to Dhaka::TOKENIZER_IDLE_STATE
     end
     for_characters digits do
-      curr_token.value += curr_char
+      curr_token.value << curr_char
       advance
     end
   end

data/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/{bracket_tokenizer.rb → brackets/bracket_tokenizer.rb}

@@ -1,10 +1,8 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-require 'bracket_grammar'
-
+require File.dirname(__FILE__) + '/bracket_grammar'
 
 class BracketTokenizer < Dhaka::Tokenizer
   
-  all_characters = ['(', '[', '{', 'B', '}', ']', ')']
+  all_characters = %w| ( [ { B } ] ) |
 
   for_state Dhaka::TOKENIZER_IDLE_STATE do
     for_characters(all_characters) do

data/test/{brackets_test.rb → brackets/brackets_test.rb}

@@ -1,7 +1,6 @@
-require "test/unit"
-
-require "bracket_grammar"
-require 'bracket_tokenizer'
+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

data/test/chittagong/chittagong_driver.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + "/chittagong_tokenizer"
+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.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.insert(unexpected_char_index, ERROR_MARKER)}"
+  end
+  
+  def evaluation_error_message evaluation_result, program
+    "#{evaluation_result.exception}:\n#{program.insert(evaluation_result.node.tokens[0].input_position, ERROR_MARKER)}"
+  end
+  
+  # lipi:run_method
+  def run(program)
+    tokenize_result = ChittagongTokenizer.tokenize(program)
+    if tokenize_result.has_error?
+      return tokenize_error_message(tokenize_result.unexpected_char_index, program) 
+    end
+    
+    parse_result = ChittagongParser.parse(tokenize_result)
+    if parse_result.has_error?
+      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