renamed parser rules for clarity. fixed

test/test_nodes.rb

@@ -25,16 +25,26 @@ class TestNodes < MiniTest::Test
   def test_args
     tree = parse "( 42 )"
     assert_kind_of Hash , tree
-    assert_kind_of Vm::IntegerExpression ,  tree[:args]
-    assert_equal 42 , tree[:args].value 
+    assert_kind_of Vm::IntegerExpression ,  tree[:argument_list]
+    assert_equal 42 , tree[:argument_list].value 
   end
   def test_arg_list
-    @parser = @parser.args
+    @parser = @parser.argument_list
     tree = parse "(42, foo)"
     assert_instance_of Array , tree
     assert_equal 42 , tree.first.value 
     assert_equal "foo" , tree.last.name 
   end
+  def test_definition
+    input    = <<HERE
+def foo(x) {
+  5
+}
+HERE
+    @parser = @parser.function_definition
+    tree = parse(input)
+    assert_kind_of Vm::IntegerExpression ,  tree
+  end
 end
 
 

test/test_parser.rb

@@ -7,7 +7,7 @@ class ParserTest < MiniTest::Test
   end
 
   def check
-    is = @parser.parse(@@input)
+    is = @parser.parse(@input)
     assert is
     assert_equal @expected , is
   end
@@ -15,28 +15,32 @@ class ParserTest < MiniTest::Test
     @input    = '42 '
     @expected = {:integer => '42'}
     @parser = @parser.integer
+    check
   end
 
   def test_name
     @input    = 'foo '
     @expected = {:name => 'foo'}
     @parser = @parser.name
+    check
   end
 
   def test_argument_list
     @input    = '(42, foo)'
-    @expected = {:args => [{:arg => {:integer => '42'}},
-                          {:arg => {:name   => 'foo'}}]}
-    @parser = @parser.args
+    @expected = {:argument_list => [{:argument => {:integer => '42'}},
+                          {:argument => {:name   => 'foo'}}]}
+    @parser = @parser.argument_list
+    check
   end
 
   def test_function_call
     @input = 'baz(42, foo)'
-    @expected = {:funcall => {:name => 'baz' },
-                :args    => [{:arg => {:integer => '42'}},
-                             {:arg => {:name => 'foo'}}]}
+    @expected = {:function_call => {:name => 'baz' },
+                :argument_list    => [{:argument => {:integer => '42'}},
+                             {:argument => {:name => 'foo'}}]}
 
-    @parser = @parser.funcall
+    @parser = @parser.function_call
+    check
   end
 
   def test_conditional
@@ -48,20 +52,22 @@ if (0) {
 }
 HERE
     @expected = {:cond     => {:integer => '0'},
-                :if_true  => {:body => {:integer => '42'}},
-                :if_false => {:body => {:integer => '667'}}}
+                :if_true  => {:block => {:integer => '42'}},
+                :if_false => {:block => {:integer => '667'}}}
     @parser = @parser.cond
+    check
   end
 
   def test_function_definition
     @input    = <<HERE
-function foo(x) {
+def foo(x) {
   5
 }
 HERE
-    @expected = {:func   => {:name => 'foo'},
+    @expected = {:function_definition   => {:name => 'foo'},
                 :params => {:param => {:name => 'x'}},
-                :body   => {:integer => '5'}}
-    @parser = @parser.func
+                :block   => {:integer => '5'}}
+    @parser = @parser.function_definition
+    check
   end
 end

test/test_transform.rb

@@ -26,25 +26,25 @@ class TransformTest <  MiniTest::Test
   end
 
   def test_argument_list
-    @input    = {:args => [{:arg => {:integer => '42'}},
-                          {:arg => {:name   => 'foo'}}]}
+    @input    = {:argument_list => [{:argument => {:integer => '42'}},
+                          {:argument => {:name   => 'foo'}}]}
     @expected = [Vm::IntegerExpression.new(42),
                 Vm::NameExpression.new('foo')]
     check_equals
   end
 
   def test_single_argument
-    @input = {:funcall => {:name => 'foo'},
-             :args    => [{:arg => {:integer => '42'}}]}
+    @input = {:function_call => {:name => 'foo'},
+             :argument_list    => [{:argument => {:integer => '42'}}]}
     @expected = Vm::FuncallExpression.new 'foo', [Vm::IntegerExpression.new(42)]
 
     check_equals
   end
 
   def test_multi_argument
-    @input = {:funcall => {:name => 'baz'},
-             :args    => [{:arg => {:integer => '42'}},
-                          {:arg => {:name => 'foo'}}]}
+    @input = {:function_call => {:name => 'baz'},
+             :argument_list    => [{:argument => {:integer => '42'}},
+                          {:argument => {:name => 'foo'}}]}
     @expected = Vm::FuncallExpression.new 'baz', [Vm::IntegerExpression.new(42),
                                           Vm::NameExpression.new('foo')]
 
@@ -53,25 +53,31 @@ class TransformTest <  MiniTest::Test
 
   def test_conditional
     @input = {:cond     => {:integer => '0'},
-             :if_true  => {:body => {:integer => '42'}},
-             :if_false => {:body => {:integer => '667'}}}
+             :if_true  => {:block => {:integer => '42'}},
+             :if_false => {:block => {:integer => '667'}}}
     @expected = Vm::ConditionalExpression.new \
       Vm::IntegerExpression.new(0),
       Vm::IntegerExpression.new(42),
       Vm::IntegerExpression.new(667)
-
     check_equals
   end
 
-  def test__function_definition
-    @input = {:func   => {:name => 'foo'},
-             :params => {:param => {:name => 'x'}},
-             :body   => {:integer => '5'}}
-    @expected = Vm::FunctionExpression.new \
-      'foo',
-      [Vm::NameExpression.new('x')],
-      Vm::IntegerExpression.new(5)
-
-      check_equals
+  def test_param
+    @input = {:param => { :name => "foo"}} 
+    @expected = Vm::NameExpression.new('foo')
+    check_equals
+  end
+  def test_params
+    @input = {:params => [{:param => { :name => "foo"}}]}
+    @expected = [Vm::NameExpression.new('foo')]
+    check_equals
+  end
+  
+  def test_function_definition
+    @input = {:function_definition => { :name => "foo"}, 
+      :params => [{ :param => { :name => "x" }}] , 
+      :block => { :integer => "5" }}
+    @expected = Vm::FunctionExpression.new('foo', [Vm::NameExpression.new('x')], Vm::IntegerExpression.new(5))
+    check_equals
   end
 end