moved nodes to parser (one more layer) and fixed tests. also adds assignment

test/test_nodes.rb

@@ -22,37 +22,37 @@ class TestNodes < MiniTest::Test
   
   def test_number
     @input    = '42 '
-    @expected = Vm::IntegerExpression.new(42)
+    @expected = Parser::IntegerExpression.new(42)
     @parser = @parser.integer
     check
   end
 
   def test_name
     @input    = 'foo '
-    @expected = Vm::NameExpression.new('foo')
+    @expected = Parser::NameExpression.new('foo')
     @parser = @parser.name
     check
   end
 
   def test_one_argument
     @input    = '(42)'
-    @expected = { :argument_list => Vm::IntegerExpression.new(42) }
+    @expected = { :argument_list => Parser::IntegerExpression.new(42) }
     @parser = @parser.argument_list
     check
   end
 
   def test_argument_list
     @input    = '(42, foo)'
-    @expected = [Vm::IntegerExpression.new(42),
-                Vm::NameExpression.new('foo')]
+    @expected = [Parser::IntegerExpression.new(42),
+                Parser::NameExpression.new('foo')]
     @parser = @parser.argument_list
     check
   end
 
   def test_function_call
     @input = 'baz(42, foo)'
-    @expected = Vm::FuncallExpression.new 'baz', [Vm::IntegerExpression.new(42),
-                                          Vm::NameExpression.new('foo')]
+    @expected = Parser::FuncallExpression.new 'baz', [Parser::IntegerExpression.new(42),
+                                          Parser::NameExpression.new('foo')]
 
     @parser = @parser.function_call
     check
@@ -64,7 +64,7 @@ class TestNodes < MiniTest::Test
 5
 else
 HERE
-    @expected = {:expressions=>[ Vm::IntegerExpression.new(4), Vm::IntegerExpression.new(5)]}
+    @expected = {:expressions=>[ Parser::IntegerExpression.new(4), Parser::IntegerExpression.new(5)]}
     
     @parser = @parser.expressions_else
     check
@@ -77,8 +77,8 @@ name
 call(4,6)
 end
 HERE
-    @expected = {:expressions=> [Vm::IntegerExpression.new(5), Vm::NameExpression.new("name"),
-      Vm::FuncallExpression.new("call", [Vm::IntegerExpression.new(4), Vm::IntegerExpression.new(6) ]) ] }
+    @expected = {:expressions=> [Parser::IntegerExpression.new(5), Parser::NameExpression.new("name"),
+      Parser::FuncallExpression.new("call", [Parser::IntegerExpression.new(4), Parser::IntegerExpression.new(6) ]) ] }
     @parser = @parser.expressions_end
     check
   end
@@ -91,9 +91,9 @@ else
   667
 end
 HERE
-    @expected = Vm::ConditionalExpression.new(  Vm::IntegerExpression.new(0),
-                                            [Vm::IntegerExpression.new(42)],
-                                            [Vm::IntegerExpression.new(667)])
+    @expected = Parser::ConditionalExpression.new(  Parser::IntegerExpression.new(0),
+                                            [Parser::IntegerExpression.new(42)],
+                                            [Parser::IntegerExpression.new(667)])
     @parser = @parser.conditional
     check
   end
@@ -104,9 +104,9 @@ def foo(x)
   5
 end
 HERE
-    @expected = Vm::FunctionExpression.new('foo', 
-                  [Vm::NameExpression.new('x')], 
-                  [Vm::IntegerExpression.new(5)])
+    @expected = Parser::FunctionExpression.new('foo', 
+                  [Parser::NameExpression.new('x')], 
+                  [Parser::IntegerExpression.new(5)])
     @parser = @parser.function_definition
     check
   end

test/test_parser.rb

@@ -105,4 +105,12 @@ HERE
     @parser = @parser.function_definition
     check
   end
+
+  def test_assignment
+    @input    = "a = 5"
+    @expected = { :asignee => { :name=>"a" } , :asigned => { :integer => "5" } }
+    @parser = @parser.assignment
+    check
+  end
+
 end

test/test_transform.rb

@@ -1,7 +1,5 @@
 require_relative 'helper'
 
-include Vm
-
 class TransformTest <  MiniTest::Test
 
   def setup
@@ -14,29 +12,29 @@ class TransformTest <  MiniTest::Test
   end
   def test_number
     @input    = {:integer => '42'}
-    @expected = Vm::IntegerExpression.new(42)
+    @expected = Parser::IntegerExpression.new(42)
     check_equals
     assert_equal 42 , @expected.value
   end
 
   def test_name
     @input    = {:name => 'foo'}
-    @expected = Vm::NameExpression.new('foo')
+    @expected = Parser::NameExpression.new('foo')
     check_equals
   end
 
   def test_argument_list
     @input    = {:argument_list => [{:argument => {:integer => '42'}},
                           {:argument => {:name   => 'foo'}}]}
-    @expected = [Vm::IntegerExpression.new(42),
-                Vm::NameExpression.new('foo')]
+    @expected = [Parser::IntegerExpression.new(42),
+                Parser::NameExpression.new('foo')]
     check_equals
   end
 
   def test_single_argument
     @input = {:function_call => {:name => 'foo'},
              :argument_list    => {:argument => {:integer => '42'} } }
-    @expected = Vm::FuncallExpression.new 'foo', [Vm::IntegerExpression.new(42)]
+    @expected = Parser::FuncallExpression.new 'foo', [Parser::IntegerExpression.new(42)]
 
     check_equals
   end
@@ -45,8 +43,8 @@ class TransformTest <  MiniTest::Test
     @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')]
+    @expected = Parser::FuncallExpression.new 'baz', [Parser::IntegerExpression.new(42),
+                                          Parser::NameExpression.new('foo')]
 
     check_equals
   end
@@ -55,20 +53,20 @@ class TransformTest <  MiniTest::Test
     @input = { :conditional => { :integer => "0"}, 
                   :if_true => {  :expressions => [ { :integer => "42" } ] } , 
                   :if_false => { :expressions => [ { :integer => "667" } ] } }
-    @expected = Vm::ConditionalExpression.new(  Vm::IntegerExpression.new(0),
-                                                [Vm::IntegerExpression.new(42)],
-                                                [Vm::IntegerExpression.new(667)])
+    @expected = Parser::ConditionalExpression.new(  Parser::IntegerExpression.new(0),
+                                                [Parser::IntegerExpression.new(42)],
+                                                [Parser::IntegerExpression.new(667)])
     check_equals
   end
 
   def test_parmeter
     @input = {:parmeter => { :name => "foo"}} 
-    @expected = Vm::NameExpression.new('foo')
+    @expected = Parser::NameExpression.new('foo')
     check_equals
   end
   def test_parmeter_list
     @input = {:parmeter_list => [{:parmeter => { :name => "foo"}}]}
-    @expected = [Vm::NameExpression.new('foo')]
+    @expected = [Parser::NameExpression.new('foo')]
     check_equals
   end
   
@@ -76,9 +74,15 @@ class TransformTest <  MiniTest::Test
     @input = {:function_definition   => {:name => 'foo'},
                 :parmeter_list => {:parmeter => {:name => 'x'}},
                 :expressions   => [{:integer => '5'}]}
-    @expected = Vm::FunctionExpression.new('foo', 
-                [Vm::NameExpression.new('x')], 
-                [Vm::IntegerExpression.new(5)])
+    @expected = Parser::FunctionExpression.new('foo', 
+                [Parser::NameExpression.new('x')], 
+                [Parser::IntegerExpression.new(5)])
+    check_equals
+  end
+
+  def test_assignment
+    @input =   { :asignee => { :name=>"a" } , :asigned => { :integer => "5" } }
+    @expected = Parser::AssignmentExpression.new("a", Parser::IntegerExpression.new(5) )
     check_equals
   end
 end