fixed tests (namespacing) and finally created a test_all

lib/parser/parser.rb

@@ -1,5 +1,5 @@
 
-module Vm
+module Parser
   class Parser < Parslet::Parser
     rule(:name)   { match('[a-z]').repeat(1).as(:name) >> space? }
     rule(:number) { match('[0-9]').repeat(1).as(:number) >> space? }

lib/parser/transform.rb

@@ -1,33 +1,33 @@
 require 'parslet'
 require 'vm/nodes'
 
-module Vm
+module Parser
   class Transform < Parslet::Transform
-    rule(:number => simple(:value)) { NumberExpression.new(value.to_i) }
-    rule(:name   => simple(:name))  { NameExpression.new(name.to_s) }
+    rule(:number => simple(:value)) { Vm::NumberExpression.new(value.to_i) }
+    rule(:name   => simple(:name))  { Vm::NameExpression.new(name.to_s) }
 
     rule(:arg  => simple(:arg))    { arg  }
     rule(:args => sequence(:args)) { args }
 
     rule(:funcall => simple(:funcall),
-         :args    => simple(:args))   { FuncallExpression.new(funcall.name, [args]) }
+         :args    => simple(:args))   { Vm::FuncallExpression.new(funcall.name, [args]) }
 
     rule(:funcall => simple(:funcall),
-         :args    => sequence(:args)) { FuncallExpression.new(funcall.name, args) }
+         :args    => sequence(:args)) { Vm::FuncallExpression.new(funcall.name, args) }
 
     rule(:cond     => simple(:cond),
          :if_true  => {:body => simple(:if_true)},
-         :if_false => {:body => simple(:if_false)}) { ConditionalExpression.new(cond, if_true, if_false) }
+         :if_false => {:body => simple(:if_false)}) { Vm::ConditionalExpression.new(cond, if_true, if_false) }
 
     rule(:param  => simple(:param))    { param  }
     rule(:params => sequence(:params)) { params }
 
     rule(:func   => simple(:func),
          :params => simple(:name),
-         :body   => simple(:body)) { FunctionExpression.new(func.name, [name], body) }
+         :body   => simple(:body)) { Vm::FunctionExpression.new(func.name, [name], body) }
 
     rule(:func   => simple(:func),
          :params => sequence(:params),
-         :body   => simple(:body)) { FunctionExpression.new(func.name, params, body) }
+         :body   => simple(:body)) { Vm::FunctionExpression.new(func.name, params, body) }
   end
 end