adjusted code and tests to use renamed and rearranged parser bits

lib/parser/transform.rb

@@ -3,7 +3,7 @@ require 'vm/nodes'
 
 module Parser
   class Transform < Parslet::Transform
-    rule(:number => simple(:value)) { Vm::NumberExpression.new(value.to_i) }
+    rule(:integer => simple(:value)) { Vm::IntegerExpression.new(value.to_i) }
     rule(:name   => simple(:name))  { Vm::NameExpression.new(name.to_s) }
 
     rule(:arg  => simple(:arg))    { arg  }

lib/vm/nodes.rb

@@ -7,7 +7,7 @@ module Vm
     end
   end
 
-  class NumberExpression < Expression
+  class IntegerExpression < Expression
     attr_reader :value
     def initialize val
       @value = val

test/test_nodes.rb

@@ -19,13 +19,13 @@ class TestNodes < MiniTest::Test
   
   def test_number
     tree = parse "42"
-    assert_kind_of Vm::NumberExpression ,  tree
+    assert_kind_of Vm::IntegerExpression ,  tree
     assert_equal 42 , tree.value 
   end
   def test_args
     tree = parse "( 42 )"
     assert_kind_of Hash , tree
-    assert_kind_of Vm::NumberExpression ,  tree[:args]
+    assert_kind_of Vm::IntegerExpression ,  tree[:args]
     assert_equal 42 , tree[:args].value 
   end
   def test_arg_list

test/test_parser.rb

@@ -13,8 +13,8 @@ class ParserTest < MiniTest::Test
   end
   def test_number
     @input    = '42 '
-    @expected = {:number => '42'}
+    @expected = {:integer => '42'}
-    @parser = @parser.number
+    @parser = @parser.integer
   end
 
   def test_name
@@ -25,7 +25,7 @@ class ParserTest < MiniTest::Test
 
   def test_argument_list
     @input    = '(42, foo)'
-    @expected = {:args => [{:arg => {:number => '42'}},
+    @expected = {:args => [{:arg => {:integer => '42'}},
                           {:arg => {:name   => 'foo'}}]}
     @parser = @parser.args
   end
@@ -33,7 +33,7 @@ class ParserTest < MiniTest::Test
   def test_function_call
     @input = 'baz(42, foo)'
     @expected = {:funcall => {:name => 'baz' },
-                :args    => [{:arg => {:number => '42'}},
+                :args    => [{:arg => {:integer => '42'}},
                              {:arg => {:name => 'foo'}}]}
 
     @parser = @parser.funcall
@@ -47,9 +47,9 @@ if (0) {
   667
 }
 HERE
-    @expected = {:cond     => {:number => '0'},
+    @expected = {:cond     => {:integer => '0'},
-                :if_true  => {:body => {:number => '42'}},
+                :if_true  => {:body => {:integer => '42'}},
-                :if_false => {:body => {:number => '667'}}}
+                :if_false => {:body => {:integer => '667'}}}
     @parser = @parser.cond
   end
 
@@ -61,7 +61,7 @@ function foo(x) {
 HERE
     @expected = {:func   => {:name => 'foo'},
                 :params => {:param => {:name => 'x'}},
-                :body   => {:number => '5'}}
+                :body   => {:integer => '5'}}
     @parser = @parser.func
   end
 end

test/test_transform.rb

@@ -13,8 +13,8 @@ class TransformTest <  MiniTest::Test
     assert_equal @expected.class , is.class
   end
   def test_number
-    @input    = {:number => '42'}
+    @input    = {:integer => '42'}
-    @expected = Vm::NumberExpression.new(42)
+    @expected = Vm::IntegerExpression.new(42)
     check_equals
     assert_equal 42 , @expected.value
   end
@@ -26,39 +26,39 @@ class TransformTest <  MiniTest::Test
   end
 
   def test_argument_list
-    @input    = {:args => [{:arg => {:number => '42'}},
+    @input    = {:args => [{:arg => {:integer => '42'}},
                           {:arg => {:name   => 'foo'}}]}
-    @expected = [Vm::NumberExpression.new(42),
+    @expected = [Vm::IntegerExpression.new(42),
                 Vm::NameExpression.new('foo')]
     check_equals
   end
 
   def test_single_argument
     @input = {:funcall => {:name => 'foo'},
-             :args    => [{:arg => {:number => '42'}}]}
+             :args    => [{:arg => {:integer => '42'}}]}
-    @expected = Vm::FuncallExpression.new 'foo', [Vm::NumberExpression.new(42)]
+    @expected = Vm::FuncallExpression.new 'foo', [Vm::IntegerExpression.new(42)]
 
     check_equals
   end
 
   def test_multi_argument
     @input = {:funcall => {:name => 'baz'},
-             :args    => [{:arg => {:number => '42'}},
+             :args    => [{:arg => {:integer => '42'}},
                           {:arg => {:name => 'foo'}}]}
-    @expected = Vm::FuncallExpression.new 'baz', [Vm::NumberExpression.new(42),
+    @expected = Vm::FuncallExpression.new 'baz', [Vm::IntegerExpression.new(42),
                                           Vm::NameExpression.new('foo')]
 
     check_equals
   end
 
   def test_conditional
-    @input = {:cond     => {:number => '0'},
+    @input = {:cond     => {:integer => '0'},
-             :if_true  => {:body => {:number => '42'}},
+             :if_true  => {:body => {:integer => '42'}},
-             :if_false => {:body => {:number => '667'}}}
+             :if_false => {:body => {:integer => '667'}}}
     @expected = Vm::ConditionalExpression.new \
-      Vm::NumberExpression.new(0),
+      Vm::IntegerExpression.new(0),
-      Vm::NumberExpression.new(42),
+      Vm::IntegerExpression.new(42),
-      Vm::NumberExpression.new(667)
+      Vm::IntegerExpression.new(667)
 
     check_equals
   end
@@ -66,11 +66,11 @@ class TransformTest <  MiniTest::Test
   def test__function_definition
     @input = {:func   => {:name => 'foo'},
              :params => {:param => {:name => 'x'}},
-             :body   => {:number => '5'}}
+             :body   => {:integer => '5'}}
     @expected = Vm::FunctionExpression.new \
       'foo',
       [Vm::NameExpression.new('x')],
-      Vm::NumberExpression.new(5)
+      Vm::IntegerExpression.new(5)
 
       check_equals
   end