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

lib/parser/basic_types.rb

@@ -6,9 +6,12 @@ module Parser
     include Parslet
     rule(:space)  { match('\s').repeat(1) }
     rule(:space?) { space.maybe }
+    rule(:eol) { (str("\n") >> space?) | any.absent? }
+    
     rule(:double_quote){ str('"') }
     rule(:minus) { str('-') }
     rule(:plus) { str('+') }
+    rule(:equal_sign) { str('=') >> space?}
     rule(:sign) { plus | minus }
     rule(:dot) { str('.') }
     rule(:digit) { match('[0-9]') }

lib/parser/composed.rb

@@ -25,6 +25,8 @@ module Parser
 
     rule(:function_call) { name.as(:function_call) >> argument_list }
 
+    rule(:assignment) { name.as(:asignee) >> equal_sign >> expression.as(:asigned) >> eol }
+
     rule(:expression) { conditional | function_call | integer | name }
 
     def delimited_expressions( delimit )
@@ -36,7 +38,7 @@ module Parser
         delimited_expressions(keyword_else).as(:if_true) >> 
         delimited_expressions(keyword_end).as(:if_false)
     }
-
+    
     rule(:expressions_else)   { delimited_expressions(keyword_else) }
     rule(:expressions_end)    { delimited_expressions(keyword_end) }
 
@@ -51,6 +53,6 @@ module Parser
         ((name.as(:parmeter) >> (comma >> name.as(:parmeter)).repeat(0)).maybe).as(:parmeter_list) >>
       right_parenthesis
     }
-    rule(:root){ function_definition | expression }
+    rule(:root){ function_definition | expression | assignment }
   end
 end

lib/parser/nodes.rb

@@ -0,0 +1,76 @@
+# ast classes
+module Parser
+  class Expression
+    def eval 
+      raise "abstract"
+    end
+    def compare other , attributes
+      attributes.each do |a|
+        left = send(a)
+        right = other.send( a)
+        return false unless left.class == right.class 
+        return false unless left == right
+      end
+      return true
+    end
+  end
+
+  class IntegerExpression < Expression
+    attr_reader :value
+    def initialize val
+      @value = val
+    end
+    def == other
+      compare other , [:value]
+    end
+  end
+
+  class NameExpression < Expression
+    attr_reader  :name
+    def initialize name
+      @name = name
+    end
+    def == other
+      compare other ,  [:name]
+    end
+  end
+
+  class FuncallExpression < Expression
+    attr_reader  :name, :args
+    def initialize name, args
+      @name , @args = name , args
+    end
+    def == other
+      compare other , [:name , :args]
+    end
+  end
+
+  class ConditionalExpression < Expression
+    attr_reader  :cond, :if_true, :if_false
+    def initialize cond, if_true, if_false
+      @cond, @if_true, @if_false = cond, if_true, if_false
+    end
+    def == other
+      compare other , [:cond, :if_true, :if_false]
+    end
+  end
+
+  class AssignmentExpression < Expression
+    attr_reader  :assignee, :assigned
+    def initialize assignee, assigned
+      @assignee, @assigned = assignee, assigned
+    end
+    def == other
+      compare other , [:assignee, :assigned]
+    end
+  end
+  class FunctionExpression < Expression
+    attr_reader  :name, :params, :block
+    def initialize name, params, block
+      @name, @params, @block = name, params, block
+    end
+    def == other
+      compare other , [:name, :params, :block]
+    end
+  end
+end

lib/parser/transform.rb

@@ -1,10 +1,10 @@
 require 'parslet'
-require 'vm/nodes'
+require_relative 'nodes'
 
 module Parser
   class Transform < Parslet::Transform
-    rule(:integer => simple(:value)) { Vm::IntegerExpression.new(value.to_i) }
-    rule(:name   => simple(:name))  { Vm::NameExpression.new(name.to_s) }
+    rule(:integer => simple(:value)) { IntegerExpression.new(value.to_i) }
+    rule(:name   => simple(:name))  { NameExpression.new(name.to_s) }
 
     rule(:argument  => simple(:argument))    { argument  }
     rule(:argument_list => sequence(:argument_list)) { argument_list }
@@ -12,17 +12,17 @@ module Parser
     # need TWO transform rules, for one/many arguments (see the[] wrapping in the first)
     rule(:function_call => simple(:function_call),
           :argument_list    => simple(:argument))   do
-            Vm::FuncallExpression.new(function_call.name, [argument]) 
+            FuncallExpression.new(function_call.name, [argument]) 
           end
     rule( :function_call => simple(:function_call), 
           :argument_list    => sequence(:argument_list)) do
-           Vm::FuncallExpression.new(function_call.name, argument_list) 
+           FuncallExpression.new(function_call.name, argument_list) 
     end
 
     rule(:conditional     => simple(:conditional),
          :if_true  => {:expressions => sequence(:if_true)},
          :if_false => {:expressions => sequence(:if_false)}) do
-           Vm::ConditionalExpression.new(conditional, if_true, if_false) 
+           ConditionalExpression.new(conditional, if_true, if_false) 
          end
 
     rule(:parmeter  => simple(:parmeter))    { parmeter  }
@@ -32,15 +32,18 @@ module Parser
     rule(:function_definition   => simple(:function_definition),
          :parmeter_list => simple(:parmeter),
          :expressions   => sequence(:expressions)) do
-            Vm::FunctionExpression.new(function_definition.name, [parmeter], expressions) 
+            FunctionExpression.new(function_definition.name, [parmeter], expressions) 
           end
 
     rule(:function_definition   => simple(:function_definition),
          :parmeter_list => sequence(:parmeter_list),
          :expressions   => sequence(:expressions)) do
-            Vm::FunctionExpression.new(function_definition.name, parmeter_list, expressions) 
+            FunctionExpression.new(function_definition.name, parmeter_list, expressions) 
           end
     
+    rule(:asignee => simple(:left) , :asigned => simple(:right) ) do
+      AssignmentExpression.new(left.name, right ) 
+    end
     #shortcut to get the ast tree for a given string
     # optional second arguement specifies a rule that will be parsed (mainly for testing)     
     def self.ast string , rule = :root