make 1.9 save

and smaller new harness

.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+sudo: false
+cache: bundler
+script:
+  - CODECLIMATE_REPO_TOKEN=2944f33533382d45c9667054d0f521b41d0d0df9b7b7f360911df8f7db76682d ruby test/test_all.rb
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.5
+  - 2.2.0

Gemfile

@@ -3,10 +3,13 @@ source "http://rubygems.org"
 gem "rake"
 
 gem "salama-reader" , :path => "."
+gem "citrus" , :github => "salama/citrus" , :branch => "gemspec-readme"
+gem "ast" #, :path => "../ast"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
+  gem "codeclimate-test-reporter", require: nil
   gem "minitest"
   gem "rubygems-tasks"
 end

Gemfile.lock

@@ -1,24 +1,44 @@
+GIT
+  remote: git://github.com/salama/citrus.git
+  revision: 34276150a67a89f84cab091fe0be7bb6a390e768
+  branch: gemspec-readme
+  specs:
+    citrus (3.0.3)
+
 PATH
   remote: .
   specs:
     salama-reader (0.2.0)
-      parslet (~> 1.7.0)
+      citrus (~> 3.0.3)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    blankslate (3.1.3)
+    ast (2.1.0)
+    codeclimate-test-reporter (0.4.6)
+      simplecov (>= 0.7.1, < 1.0.0)
+    docile (1.1.5)
     minitest (5.6.1)
-    parslet (1.7.0)
-      blankslate (>= 2.0, <= 4.0)
+    multi_json (1.11.2)
     rake (10.4.2)
     rubygems-tasks (0.2.4)
+    simplecov (0.9.2)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.9.0)
+    simplecov-html (0.9.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  ast
+  citrus!
+  codeclimate-test-reporter
   minitest
   rake
   rubygems-tasks
   salama-reader!
+
+BUNDLED WITH
+   1.10.5

README.md

@@ -1,14 +1,16 @@
-## Salama Reader*
+[![Build Status](https://travis-ci.org/salama/salama-reader.svg?branch=master)](https://travis-ci.org/salama/salama-reader)
+[![Gem Version](https://badge.fury.io/rb/salama-reader.svg)](http://badge.fury.io/rb/salama-reader)
+[![Code Climate](https://codeclimate.com/github/salama/salama-reader/badges/gpa.svg)](https://codeclimate.com/github/salama/salama-reader)
+[![Test Coverage](https://codeclimate.com/github/salama/salama-reader/badges/coverage.svg)](https://codeclimate.com/github/salama/salama-reader)
 
-The parser part of salama is now a standalone gem. It parses ruby using Parslet and no other dependencies.
+## Salama Reader
+
+The parser part of salama is now a standalone gem. It parses ruby using Citrus and no other dependencies.
 
 This is interesting if you want to generate executable code, like salama, but also for other things, like code analysis.
 
 Also it is very educational, as it is very readable code, and not too much of it.
 
-*
-It looks into it's salama ball and all it sees is red. A red salama . . . ruby, yes.
-
 ### Parser
 
 The main parser per se is in parser/salama , but it just pulls in all the parts.
@@ -27,7 +29,6 @@ Most names are quite self explanatory, but here is a list:
 - return statement are straightforward
 - while still needs a do, though i think in ruby a newline is sufficient
 
-**Transform** defines how the rules map to Ast objects.
 
 ### Ast
 
@@ -38,17 +39,12 @@ The Classes don't really define any functionality, that is done in Salama, or ca
 The functionality that is in there is mainly to do with testing. Equality is defined, but also **inspect** in such a way that it's output (which you get from a failing test) can be pasted straight into the test case as the expected result.
 
 
-### Parslet
+### Citrus
 
-Parslet is really great in that it:
-- does not generate code but instead gives a clean dsl to define a grammar
+Citrus is really great in that it:
+- does not generate code but instead gives a syntax to define a grammar
 - uses ruby modules so one can split the grammars up
-- has support for binary operators with precedence and binding
-- has a separate transform stage to generate an ast layer
 
-Especially the last point is great. Since it is separate it does not clutter up the actual grammar.
-And it can generate a layer that has no links to the actual parser anymore, thus saving/automating
-a complete transformation process.
 
 ### Todo
 
@@ -63,7 +59,7 @@ A random list of things left for the future
 
 ### Operators
 
-Parslets operator support is **outstanding** and such it was a breeze to implement most of rubies operators very simply. See the operators.rb for details. Below is a list from the web of how it should be.
+See the operators.rb for details. Below is a list from the web of how it should be.
 
 
 Operator list from http://stackoverflow.com/questions/21060234/ruby-operator-precedence-table

lib/ast/basic_expressions.rb

@@ -7,52 +7,112 @@ module Ast
     def initialize val
       @value = val
     end
-    def inspect
-      self.class.name + ".new(" + value.to_s+ ")"
-    end
-    def to_s
-      value.to_s
-    end
     def attributes
       [:value]
     end
+
+    def to_s
+      value.to_s
+    end
   end
 
   class TrueExpression < Expression
     def to_s
-      "true"
+      ""
     end
+  def attributes
+    []
+  end
   end
   class FalseExpression < Expression
     def to_s
-      "false"
+      ""
+    end
+    def attributes
+      []
     end
   end
   class NilExpression < Expression
     def to_s
-      "nil"
+      ""
+    end
+    def attributes
+      []
     end
   end
-  
+
   class NameExpression < Expression
     attr_reader  :name
     def initialize name
       @name = name.to_sym
     end
+    def attributes
+      [:name]
+    end
     def inspect
       "#{self.class.name}.new(#{name.inspect})"
     end
     def to_s
       name.to_s
     end
+  end
+
+  class TypedName < NameExpression
+    attr_reader  :type
+    def initialize type , name
+      super(name)
+      @type = type.to_sym
+    end
     def attributes
-      [:name]
+      [:type, :name]
+    end
+    def inspect
+      "#{self.class.name}.new(#{type.inspect},#{name.inspect})"
+    end
+    def to_s
+      inspect
+    end
+  end
+
+  class VariableDefinition < TypedName
+    attr_reader  :right
+
+    def initialize type , name , right
+      super(type , name)
+      @right = right
+    end
+    def attributes
+      super + [:right]
+    end
+    def inspect
+      self.class.name + ".new(" +  type.inspect + "," + name.inspect + "," + right.inspect + ")"
+    end
+    def to_s
+      inspect
     end
   end
 
   class VariableExpression < NameExpression
   end
 
+  class AssignmentExpression < NameExpression
+    attr_reader  :right
+
+    def initialize name, right
+      super(name)
+      @right = right
+    end
+    def attributes
+      super + [:right]
+    end
+    def inspect
+      self.class.name + ".new(" +  name.inspect + "," + right.inspect + ")"
+    end
+    def to_s
+      "#{left} = #{right}"
+    end
+  end
+
   class ModuleName < NameExpression
   end
 
@@ -61,15 +121,15 @@ module Ast
     def initialize str
       @string = str
     end
+    def attributes
+      [:string]
+    end
     def inspect
       self.class.name + '.new("' + string + '")'
     end
     def to_s
       '"' + string.to_s + '"'
     end
-    def attributes
-      [:string]
-    end
   end
 
-end
+end

lib/ast/block_expression.rb

@@ -8,19 +8,14 @@ module Ast
       @body_exp =  body_exp
     end
 
-    def attributes
-      [:call_exp, :args , :body_exp]
-    end
-
-    def inspect
-      self.class.call_exp + ".new(" + call_exp.inspect + ", ["+
-        args.collect{|m| m.inspect }.join( ",") + "] ," + body_exp.inspect  + ")"
-    end
-    def to_s
-      "#{call_exp}(" + args.join(",") + ")"
-    end
     def attributes
       [:call_exp , :args , :body_exp]
     end
+
+    def to_s
+      call_exp.inspect + ", ["+
+        args.collect{|m| m.inspect }.join( ",") + "] ," + body_exp.inspect
+    end
+  
   end
 end

lib/ast/call_site_expression.rb

@@ -1,24 +1,35 @@
 module Ast
-  # assignment, like operators are really function calls
-  
-  class CallSiteExpression < Expression
-    attr_reader  :name, :args , :receiver
 
-    def initialize name, args , receiver = Ast::NameExpression.new(:self)
-      @name = name.to_sym
-      @args = args 
+  class FieldExpression < Expression
+    attr_reader  :receiver , :name
+
+    def initialize receiver , name
       @receiver =  receiver
-    end
-    
-    def inspect
-      self.class.name + ".new(" + name.inspect + ", ["+ 
-        args.collect{|m| m.inspect }.join( ",") + "] ," + receiver.inspect  + ")"  
-    end
-    def to_s
-      "#{name}(" + args.join(",") + ")"
+      @name = name.to_sym
     end
     def attributes
-      [:name , :args , :receiver]
+      [:receiver , :name]
     end
-  end  
-end
+
+    def to_s
+      receiver.inspect + "," + name.inspect
+    end
+  end
+
+  class CallSiteExpression < Expression
+    attr_reader  :field , :args
+
+    def initialize field, args
+      @field = field
+      @args = args
+    end
+    def attributes
+      [:field , :args]
+    end
+
+    def to_s
+      field.inspect + ", ["+
+        args.collect{|m| m.inspect }.join( ",") + "] "
+    end
+  end
+end

lib/ast/compound_expressions.rb

@@ -2,29 +2,33 @@ module Ast
 
   class ArrayExpression < Expression
     attr_reader :values
-    def initialize vals
-      @values = vals
-    end
-    def inspect
-      self.class.name + ".new(" + values.to_s+ ")"
-    end
     def attributes
       [:values]
     end
+    def initialize vals
+      @values = vals
+    end
+    def to_s
+      values.to_s
+    end
   end
+
   class AssociationExpression < Expression
     attr_reader :key , :value
+
     def initialize key , value
       @key , @value = key , value
     end
-    def inspect
-      self.class.name + ".new(" + key.inspect + " , " + value.inspect + ")"
-    end
+
     def attributes
       [:key , :value]
     end
 
+    def to_s
+      key.inspect + " , " + value.inspect
+    end
+
   end
   class HashExpression < ArrayExpression
   end
-end
+end

lib/ast/expression.rb

@@ -7,20 +7,61 @@
 
 # PS: compare is only for tests and should be factored out to there
 
+Array.class_eval do
+  def to_basic
+    collect do |item|
+      item.to_basic
+    end
+  end
+end
+Symbol.class_eval do
+  def to_basic
+    to_s
+  end
+end
+String.class_eval do
+  def to_basic
+    to_s
+  end
+end
 module Ast
   class Expression
     def attributes
-      []
+      raise "abstract called for #{self}"
     end
+    def to_basic()
+      data = { "class" => self.class.name }
+      attributes.each do |name|
+        val = instance_variable_get("@#{name}".to_sym)
+        res = val.to_basic
+        data[name] = res
+      end
+      data
+    end
+
+    def self.from_basic(hash)
+      clazz = hash.delete("class")
+      keys = hash.keys
+      klass = clazz.split("::").inject(Object) {|o,c| o.const_get(c)}
+      keys.delete("class")
+      values = keys.collect{|k| read_basic(hash[k]) }
+      klass.new(*values)
+    end
+    def self.read_basic val
+      return from_basic(val) if val.is_a?(Hash)
+      return val.collect{|i| from_basic(i)} if(val.is_a? Array )
+      val
+    end
+
     def inspect
-      self.class.name + ".new()"
+      self.class.name + ".new(#{to_s})"
     end
     def == other
-      return false unless other.class == self.class 
+      return false unless other.class == self.class
       attributes.each do |a|
         left = send(a)
         right = other.send(a)
-        return false unless left.class == right.class 
+        return false unless left.class == right.class
         return false unless left == right
       end
       return true

lib/ast/expression_list.rb

@@ -4,15 +4,14 @@ module Ast
     def initialize expressions
       @expressions = expressions
     end
+
     def attributes
       [:expressions]
     end
-    def inspect
-      self.class.name + ".new( ["+ expressions.collect(&:inspect).join( ",") +"])"
-    end
 
     def to_s
-      expressions.collect(&:inspect).join("\n")
+      "["+ expressions.collect(&:inspect).join( ",") +"]"
     end
+
   end
-end
+end

lib/ast/function_expression.rb

@@ -10,16 +10,10 @@ module Ast
     def attributes
       [:name, :params, :body , :receiver]
     end
-    def inspect
-      self.class.name + ".new(" + name.inspect + ", ["+ 
-        params.collect{|m| m.inspect }.join( ",") +"] , [" + 
-        body.collect{|m| m.inspect }.join( ",") +"] ,"+  receiver.inspect + " )"
-    end
-    
     def to_s
-      ret = "def "
-      ret += "#{receiver}." if receiver
-      ret + "#{name}( " + params.join(",") + ") \n" + body.join("\n") + "end\n"
+      name.inspect + ", ["+
+        params.collect{|m| m.inspect }.join( ",") +"] , [" +
+        body.collect{|m| m.inspect }.join( ",") +"] ,"+  receiver.inspect
     end
   end
-end
+end

lib/ast/if_expression.rb

@@ -4,12 +4,12 @@ module Ast
     def initialize cond, if_true, if_false
       @cond, @if_true, @if_false = cond, if_true, if_false
     end
-    def inspect
-      self.class.name + ".new(" + cond.inspect + ", "+ 
-        if_true.inspect +  ","  + if_false.inspect + " )"  
-    end
     def attributes
       [:cond, :if_true, :if_false]
     end
+
+    def to_s
+      cond.inspect + ", " + if_true.inspect +  ","  + if_false.inspect
+    end
   end
-end
+end

lib/ast/module_expression.rb

@@ -7,15 +7,13 @@ module Ast
       @name = name.to_sym
       @expressions = expressions
     end
-    def inspect
-      self.class.name + ".new(" + @name.inspect + " ," + @expressions.inspect + " )"  
-    end
-    def to_s
-      "module #{name}\n #{expressions}\nend\n"
-    end
     def attributes
       [:name , :expressions]
     end
+
+    def to_s
+      name.inspect + " ," + expressions.inspect
+    end
   end
 
   class ClassExpression < ModuleExpression
@@ -24,18 +22,16 @@ module Ast
       super(name , expressions)
       @derived_from = derived
     end
-    def inspect
-      self.class.name + ".new(" + @name.inspect + " ," + 
-                                @derived_from.inspect + ", " + @expressions.inspect + " )"  
-    end
-    def derived_from
-      @derived_from ? @derived_from : :Object
-    end
-    def to_s
-      s = "class #{name} < #{derived_from}\n #{expressions}\nend\n"
-    end
     def attributes
       [:name , :derived_from , :expressions]
     end
+
+    def derived_from
+      @derived_from ? @derived_from : :Object
+    end
+    
+    def to_s
+      name.inspect + " ," + derived_from.inspect + ", " + expressions.inspect
+    end
   end
-end
+end

lib/ast/operator_expressions.rb

@@ -1,36 +1,18 @@
 module Ast
-    
+
   class OperatorExpression < Expression
     attr_reader  :operator, :left, :right
 
     def initialize operator, left, right
       @operator, @left, @right = operator, left, right
     end
+
     def attributes
       [:operator, :left, :right]
     end
-    def inspect
-      self.class.name + ".new(" + operator.inspect + ", " +  left.inspect + "," + right.inspect + ")"  
-    end
-    def to_s
-      "#{left} #{operator} #{right}"
-    end
-  end
 
-  class AssignmentExpression < Expression
-    attr_reader  :left, :right
-
-    def initialize left, right
-      @left, @right = left, right
-    end
-    def attributes
-      [:left, :right]
-    end
-    def inspect
-      self.class.name + ".new(" +  left.inspect + "," + right.inspect + ")"  
-    end
     def to_s
-      "#{left} = #{right}"
+      operator.inspect + ", " +  left.inspect + "," + right.inspect
     end
   end
 

lib/ast/return_expression.rb

@@ -4,14 +4,12 @@ module Ast
     def initialize expression
       @expression = expression
     end
-    def inspect
-      self.class.name + ".new(" + expression.inspect + " )"  
-    end
-    def to_s
-      "return #{expression}\n"
-    end
     def attributes
       [:expression]
     end
+
+    def to_s
+      expression.inspect
+    end
   end
-end
+end

lib/ast/while_expression.rb

@@ -1,17 +1,17 @@
 module Ast
   class WhileExpression < Expression
     attr_reader  :condition, :body
+
     def initialize condition, body
       @condition , @body = condition , body
     end
-    def inspect
-      self.class.name + ".new(" + condition.inspect + ", "  + body.inspect + " )"  
-    end
-    def to_s
-      "while(#{condition}) do\n" + body.join("\n") + "\nend\n"
-    end
+
     def attributes
       [:condition, :body]
     end
+
+    def to_s
+      condition.inspect + ", "  + body.inspect  
+    end
   end
-end
+end

lib/parser/bosl.citrus

@@ -0,0 +1,244 @@
+
+grammar Bosl
+
+  # unicode generalized categories , according to regex ruby page
+  rule lower  /[[:lower:]]/ end    # Lowercase alphabetical character
+  rule upper  /[[:upper:]]/ end    # Uppercase alphabetical
+  rule alnum  /[[:alnum:]]/ end    # Alphabetic and numeric character
+  rule alpha  /[[:alpha:]]/ end    # Alphabetic character
+  rule blank  /[[:blank:]]/ end    # Space or tab
+  rule space  /[[:space:]]/ end    # Whitespace character ([:blank:], newline, carriage return, etc.)
+  rule digit  /[[:digit:]]/ end    # Digit
+  rule graph  /[[:graph:]]/ end    # Non-blank character (excludes spaces, control characters, and similar)
+  rule print  /[[:print:]]/ end    # Like [:graph:], but includes the space character
+  rule xdigit /[[:xdigit:]]/ end   # Digit allowed in a hexadecimal number (i.e., 0-9a-fA-F)
+
+  rule linebreak (!blank space) end  #define in regex terms for utf
+
+  rule comment  #don't include the newline (which ends the comment)
+    "#" /.*/
+  end
+
+  rule name_expression
+     (name:([a-z_] [a-zA-Z0-9_]*) space*) { capture(:name).to_str}
+  end
+
+  rule aspect_name_expression
+     (name:([A-Z] [a-zA-Z0-9_]*) space*) { s(:aspect , capture(:name).to_str)}
+  end
+
+  rule digits
+    [0-9] [0-9]*
+  end
+
+  rule integer_expression
+    (digits space*) { s(:int , to_str.to_i) }
+  end
+
+  rule string_expression
+    #"'" (/.*/ !"'") "'"
+     ('"' str:(!'"' .)* '"') {s(:string , capture(:str).to_str) }
+  end
+
+  rule basic_expression
+    name_expression | integer_expression  |
+    aspect_name_expression | string_expression
+  end
+
+  rule keyword_begin    'begin'  space* end
+  rule keyword_class    'class'  space*  end
+  rule keyword_def      'def'    space*  end
+  rule keyword_do       'do'     space* end
+  rule keyword_else     'else'   space*  end
+  rule keyword_end      'end'    space*  end
+  rule keyword_if       'if'       end
+  rule keyword_rescue   'rescue' space* end
+  rule keyword_return   'return' space* end
+  rule keyword_aspect   'aspect' space*  end
+  rule keyword_unless   'unless' space* end
+  rule keyword_while    'while'  space* end
+
+  rule keyword_nil
+    ('nil'    space* ){ s(:nil) }
+  end
+
+  rule keyword_false
+    ('false'  space*) { s(:false) }
+  end
+
+  rule keyword_true
+    ('true'   space*) { s(:true) }
+  end
+
+  # this rule is just to make sure identifiers can't be keywords. Kind of duplication here, but we need the
+  # space in above rules, so just make sure to add any here too.
+  rule keyword   ('begin'  |  'def'  |  'do'  |  'else'  |  'end'  |
+                   'false' |  'if' |  'rescue' |  'true' |  'nil'  |
+                   'unless' |  'until' |  'while') space*
+  end
+
+  rule keyword_expression
+    keyword_true | keyword_false | keyword_nil | basic_expression
+  end
+
+
+  # Tokens are single or double character combinations with "meaning"
+  # braces, comman, point, questionmark , quotes, that kind of thing
+  # operator symbols are separate in Opreators
+
+  rule left_parenthesis
+     '('  space*
+  end
+
+  rule right_parenthesis
+    ')' space*
+  end
+
+  rule left_brace
+    '{'  space*
+  end
+
+  rule right_brace
+    '}'  space*
+  end
+
+  rule left_bracket
+    '['  space*
+  end
+
+  rule right_bracket
+    ']'  space*
+  end
+
+  rule association
+    "=>"  space*
+  end
+
+  rule comma
+    ','  space*
+  end
+
+  rule colon
+    ':'  space*
+  end
+
+  rule semicolon
+    ';'  space*
+  end
+
+  rule question_mark
+    '?' space*
+  end
+
+  rule excamation_mark
+    '!' space*
+  end
+
+  rule more_args
+    (comma basic_expression )* {
+      captures(:basic_expression).collect{|u| u.value }
+    }
+  end
+
+  rule argument_list
+    (left_parenthesis basic_expression? more_args right_parenthesis){
+        args = [ ]
+        args << capture(:basic_expression).value if capture(:basic_expression)
+        args += capture(:more_args).value if capture(:more_args)
+        args
+        }
+  end
+
+  rule call_site
+    (field_expression  argument_list space?) {
+      s(:call , capture(:field_expression).value , capture(:argument_list).value  )
+    }
+  end
+
+  rule field_expression
+    (basic_expression "." name_expression  space?) {
+      s(:field , capture(:basic_expression).value ,
+                          capture(:name_expression).value )
+    }
+  end
+
+  rule value_expression
+    call_site | basic_expression
+  end
+
+  rule function_definition
+    keyword_def name:function_name  parameter_list  newline expressions_end  newline
+  end
+
+  rule parameter_list
+    left_parenthesis parameter_list:( name:parameter?  (comma name:parameter)* ) right_parenthesis
+  end
+
+  rule more_typed_args
+    (comma typed_arg )* {
+      captures(:typed_arg).collect{|u| u.value }
+    }
+  end
+
+  rule typed_argument_list
+    (left_parenthesis typed_arg? more_typed_args right_parenthesis){
+        args = [ ]
+        args << capture(:typed_arg).value if capture(:typed_arg)
+        args += capture(:more_typed_args).value if capture(:more_typed_args)
+        args
+        }
+  end
+
+  rule type
+    (typ:("int" | "ref") space*) { capture(:typ).to_s }
+  end
+
+  rule typed_arg
+    (type name_expression) {
+      s(:type , capture(:type).value , capture(:name_expression).value)
+    }
+  end
+
+  rule variable_definition
+    (typed_arg ("=" space* value_expression)?) {
+      value = capture(:value_expression) ? capture(:value_expression).value : nil
+      s(:variable , capture(:typed_arg).value , value )
+    }
+  end
+
+  rule assignment
+    (name_expression "=" space* value_expression){
+    s(:assign ,  capture(:name_expression).value.to_sym , capture(:value_expression).value)
+    }
+  end
+
+  rule conditional
+    (keyword_if left_parenthesis value_expression right_parenthesis
+    body
+    keyword_end)  {
+      s(:if ,  s(:cond , capture(:value_expression).value )  , s(:then , capture(:body).value) )
+    }
+  end
+
+  rule while
+    keyword_while left_parenthesis value_expression right_parenthesis keyword_do
+    body
+    keyword_end
+  end
+
+  rule return
+    keyword_return value_expression newline
+  end
+
+  rule body
+    (statement+){
+      captures(:statement).collect{|u| u.value }
+    }
+  end
+
+  rule statement
+    conditional | while | return | variable_definition | assignment | call_site
+  end
+
+
+end

lib/parser/compound_types.rb

@@ -1,7 +1,7 @@
 module Parser
   # Compound types are Arrays and Hashes
   module CompoundTypes
-    include Parslet
+    include output
 
     rule(:array_constant) do
       left_bracket >>

lib/parser/control.rb

@@ -1,6 +1,6 @@
 module Parser
   module Control
-    include Parslet
+    include output
     rule(:conditional) do
       keyword_if >> 
       (( (value_expression|operator_expression).as(:conditional) ) |

lib/parser/module_definition.rb

@@ -1,6 +1,6 @@
 module Parser
   module ModuleDef
-    include Parslet
+    include output
     rule(:module_definition) do
       keyword_module >> module_name >> eol >>
       ( (keyword_end.absent? >> root_body).repeat()).as(:module_expressions) >> keyword_end >> newline

lib/parser/operators.rb

@@ -1,6 +1,6 @@
 module Parser
   module Operators
-    include Parslet
+    include output
     rule(:exponent) { str('**') >> space?}
     rule(:multiply) { match['*/%']  >> space? }
     rule(:plus) { match['+-']  >> space? }

lib/parser/salama.rb

@@ -1,38 +1,11 @@
-require_relative "basic_types"
-require_relative "compound_types"
-require_relative "tokens"
-require_relative "keywords"
-require_relative "control"
-require_relative "expression"
-require_relative "call_site"
-require_relative "function_definition"
-require_relative "module_definition"
-require_relative "operators"
+require "ast"
 
 module Parser
-  
+
   # obviously a work in progress !!
-  # We "compose" the parser from bits, divide and hopefully conquer
-   
-  # a note about .maybe : .maybe is almost every respect the same as .repeat(0,1)
-  # so either 0, or 1, in other words maybe. Nice feature, but there are strings attached:
-  # a maybe removes the 0  a sequence (array) to a single (hash). Thus 2 transformations are needed
-  # More work than the prettiness is worth, so only use .maybe on something that does not need capturing
 
-  class Salama < Parslet::Parser
-    include BasicTypes
-    include CompoundTypes
-    include Tokens
-    include Keywords
-    include Control
-    include Expression
-    include CallSite
-    include FunctionDefinition
-    include Operators
-    include ModuleDef
+  Citrus::Match.send :include , AST::Sexp
+
+  Citrus.require "parser/bosl"
 
-    rule(:root_body)    {(module_definition | class_definition | function_definition | expression  | 
-                          operator_expression | call_site | basic_type | hash_constant | array_constant )}
-    rule(:root)         { root_body.repeat.as(:expression_list) }
-  end
 end

lib/parser/transform.rb

@@ -2,7 +2,7 @@ require 'parslet'
 require 'ast/expression'
 
 module Parser
-  class Transform < Parslet::Transform
+  class Transform < output::Transform
     rule(:string => sequence(:chars)) { Ast::StringExpression.new chars.join }
     rule(:esc => simple(:esc)) { '\\' +  esc }
     rule(char: simple(:char)) { char }

lib/salama-reader.rb

@@ -1,3 +1,3 @@
-require 'parslet'
+require 'citrus'
 require 'parser/salama'
-require 'parser/transform'
+#require 'parser/transform'

lib/skip/basic_types.rb

@@ -1,7 +1,7 @@
 module Parser
   # Basic types are numbers and strings
   module BasicTypes
-    include Parslet
+    include output
     # space really is just space. ruby is newline sensitive, so there is more whitespace footwork
     # rule of thumb is that anything eats space behind it, but only space, no newlines
     rule(:space)  { (str('\t') | str(' ')).repeat(1) }

lib/skip/call_site.rb

@@ -1,6 +1,6 @@
 module Parser
   module CallSite
-    include Parslet
+    include output
 
     rule(:argument_list) {
       left_parenthesis >>

lib/skip/expression.rb

@@ -1,6 +1,6 @@
 module Parser
   module Expression
-    include Parslet
+    include output
     
     rule(:value_expression) { call_site | basic_type }
 

lib/skip/function_definition.rb

@@ -1,6 +1,6 @@
 module Parser
   module FunctionDefinition
-    include Parslet
+    include output
     
     rule(:function_definition) {
       keyword_def >> ((module_name|instance_variable|name).as(:receiver) >> str(".")).maybe >> #possibly qualified

lib/skip/keywords.rb

@@ -1,6 +1,6 @@
 module Parser
   module Keywords
-    include Parslet
+    include output
     
     rule(:keyword_begin)  {  str('begin').as(:begin) >> space?}
     rule(:keyword_class)  {  str('class') >> space? }

lib/skip/tokens.rb

@@ -3,7 +3,7 @@ module Parser
   # braces, comman, point, questionmark , quotes, that kind of thing
   # operator symbols are separate in Opreators
   module Tokens
-    include Parslet
+    include output
     rule(:left_parenthesis) { str('(') >> space? }
     rule(:right_parenthesis) { str(')') >> space? }
     rule(:left_brace)  { str('{')    >> space? }

salama-reader.gemspec

@@ -13,6 +13,6 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
   s.summary = 'Ruby parser for the salama machine'
 
-  s.add_dependency 'parslet', '~> 1.7.0'
+  s.add_dependency 'citrus', '~> 3.0.3'
 
 end

test/README.md

@@ -43,10 +43,10 @@ test method. See test_basic for easy example.
 Example:
 
   def test_number
-    @string_input    = '42 '
+    @input    = '42 '
     @test_output = {:integer => '42'}
-    @transform_output = Parser::IntegerExpression.new(42)
-    @parser = @parser.integer
+    @output = Parser::IntegerExpression.new(42)
+    @root = :integer
   end
 
 The first three lines define the data as described above.

test/parser_helper.rb

@@ -1,65 +1,21 @@
 require_relative "setup"
-require "parslet/convenience"
+require "ast"
 
-# remove the line numbers on assert fails, so it's easy to copy paste the result as the expected result
-Parslet::Slice.class_eval do
-  def inspect
-    '"'  + to_s + '"'
-  end
-end
 # Included in parser test will create tests methods
 module ParserHelper
-  
+  include AST::Sexp
+
   def self.included(base)
-    base.send :include, InstanceMethods  #provides helpers and setup
-    base.send :extend, ClassMethods   #gets the method creation going
-  end
- 
-  module InstanceMethods
-    def setup
-      @parser    = Parser::Salama.new
-      @transform = Parser::Transform.new
-    end
-
-    # check that @string_input parses correctly to @parse_output
-    def check_parse
-      is = @parser.parse_with_debug(@string_input)
-      assert_equal @parse_output , is
-    end
-
-    #check that @parse_output transforms to @transform_output
-    def check_transform
-      is = @transform.apply @parse_output
-      #puts is.transform
-      assert_equal @transform_output , is
-    end
-
-    # check that @string_input parses and transforms to @transform_output
-    def check_ast
-      syntax    = @parser.parse(@string_input)
-      is      = @transform.apply(syntax)
-      #puts is.inspect
-      assert_equal @transform_output , is
-    end
+#    base.send :include, InstanceMethods  #provides helpers and setup
   end
 
-  module ClassMethods
-    # this creates test methods dynamically. For each test_* method we create 
-    # three test_*[ast/parse/transf] methods that in turn check the three phases.
-    # runnable_methods is called by minitest to determine which tests to run
-    def runnable_methods
-      tests = []
-      public_instance_methods(true).grep(/^test_/).map(&:to_s).each do |test|
-        ["ast" , "transform" , "parse"].each do |what|
-          name = "#{test}_#{what}"
-          tests << name
-          self.send(:define_method, name ) do
-            send(test)
-            send("check_#{what}")
-          end
-        end
-      end
-      tests
-    end
-   end
+  def setup
+    @parser = Bosl
+  end
+
+  def check rule = :root
+    parse    = @parser.parse(@input , :root => rule)
+    assert_equal @input , parse
+    assert_equal @output , parse.value
+  end
 end

test/roots/test_basic.rb

@@ -3,61 +3,54 @@ require_relative "../parser_helper"
 class RootTestBasic < MiniTest::Test
   # include the magic (setup and parse -> test method translation), see there
   include ParserHelper
-    
+
   def test_number
-    @string_input    = '42 '
-    @parse_output = {:expression_list=>[{:integer=>"42"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::IntegerExpression.new(42)])
+    @input    = '42 '
+    @output = Ast::ExpressionList.new( [Ast::IntegerExpression.new(42)])
   end
 
   def test_name
-    @string_input    = 'foo '
-    @parse_output = {:expression_list=>[{:name=>"foo"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::NameExpression.new(:foo)])
+    @input    = 'foo '
+    @output = Ast::ExpressionList.new( [Ast::NameExpression.new(:foo)])
   end
 
   def test_name_underscode_start
-    @string_input    = '_bar '
-    @parse_output = {:expression_list=>[{:name=>"_bar"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::NameExpression.new(:_bar)])
+    @input    = '_bar '
+    @output = Ast::ExpressionList.new( [Ast::NameExpression.new(:_bar)])
   end
 
   def test_name_underscode_middle
-    @string_input    = 'foo_bar '
-    @parse_output = {:expression_list=>[{:name=>"foo_bar"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::NameExpression.new(:foo_bar)])
+    @input    = 'foo_bar '
+    @output = Ast::ExpressionList.new( [Ast::NameExpression.new(:foo_bar)])
   end
 
   def test_instance_variable
-    @string_input    = '@foo_bar '
-    @parse_output = {:expression_list=>[{:instance_variable=>{:name=>"foo_bar"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::VariableExpression.new(:foo_bar)])
+    @input    = '@foo_bar '
+    @output = Ast::ExpressionList.new( [Ast::VariableExpression.new(:foo_bar)])
   end
 
   def test_module_name
-    @string_input    = 'FooBar '
-    @parse_output = {:expression_list=>[{:module_name=>"FooBar"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ModuleName.new(:FooBar)])
+    @input    = 'FooBar '
+    @output = Ast::ExpressionList.new( [Ast::ModuleName.new(:FooBar)])
   end
 
   def ttest_comment
     out = "# i am a comment \n"
-    @string_input    =  out.dup #NEEDS the return, which is what delimits the comment
-    @parse_output = out
-    @transform_output = @parse_output #dont transform
+    @input    =  out.dup #NEEDS the return, which is what delimits the comment
+    @output = @parse_output #dont transform
   end
 
   def test_string
-    @string_input    = "\"hello\""
+    @input    = "\"hello\""
     @parse_output =  {:expression_list=>[{:string=>[{:char=>"h"}, {:char=>"e"}, {:char=>"l"}, {:char=>"l"}, {:char=>"o"}]}]}
-    @transform_output =  Ast::ExpressionList.new( [Ast::StringExpression.new("hello")])
+    @output =  Ast::ExpressionList.new( [Ast::StringExpression.new("hello")])
   end
 
   def test_string_escapes
     out = 'hello  \nyou'
-    @string_input    = '"' + out + '"'
+    @input    = '"' + out + '"'
     @parse_output = {:expression_list=>[{:string=>[{:char=>"h"}, {:char=>"e"}, {:char=>"l"}, {:char=>"l"}, {:char=>"o"}, {:char=>" "}, {:char=>" "}, {:esc=>"n"}, {:char=>"y"}, {:char=>"o"}, {:char=>"u"}]}]}
-    @transform_output =  Ast::ExpressionList.new( [Ast::StringExpression.new(out)])
+    @output =  Ast::ExpressionList.new( [Ast::StringExpression.new(out)])
   end
 
-end
+end

test/roots/test_block.rb

@@ -5,19 +5,19 @@ class RootTestBlock < MiniTest::Test
   include ParserHelper
 
   def pest_block
-    @string_input = <<HERE
+    @input = <<HERE
 self.call(1) do |a , b|
   tmp = a
   puts(b)
 end
 HERE
     @parse_output = nil
-    @transform_output = nil
-    @parser = @parser
+    @output = nil
+    @root = :
   end
 
   def pest_big_block
-    @string_input = <<HERE
+    @input = <<HERE
 self.call( true , false) do | a , b |
   tmp = a
   a = b
@@ -27,7 +27,7 @@ self.call( true , false) do | a , b |
 end
 HERE
     @parse_output = {:expression_list=>[{:while=>"while", :while_cond=>{:l=>{:name=>"n"}, :o=>"> ", :r=>{:integer=>"1"}}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:l=>{:name=>"a"}, :o=>"= ", :r=>{:name=>"b"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:l=>{:name=>"tmp"}, :o=>"+ ", :r=>{:name=>"b"}}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}, {:l=>{:name=>"n"}, :o=>"= ", :r=>{:l=>{:name=>"n"}, :o=>"- ", :r=>{:integer=>"1"}}}], :end=>"end"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::BlockExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::BlockExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )])
+    @root = :
   end
 end

test/roots/test_call_site.rb

@@ -5,107 +5,107 @@ class RootTestCallSite < MiniTest::Test
   include ParserHelper
     
   def test_single_argument
-    @string_input = 'foo(42)'
+    @input = 'foo(42)'
     @parse_output = {:expression_list=>[{:call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"42"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::NameExpression.new(:self))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::NameExpression.new(:self))])
+    @root = :
   end
 
   def test_single_self
-    @string_input = 'self.foo(42)'
+    @input = 'self.foo(42)'
     @parse_output = {:expression_list=>[{:receiver=>{:name=>"self"}, :call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"42"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::NameExpression.new(:self))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::NameExpression.new(:self))])
+    @root = :
   end
 
   def test_single_instance
-    @string_input = '@var.foo(42)'
+    @input = '@var.foo(42)'
     @parse_output = {:expression_list=>[{:receiver=>{:instance_variable=>{:name=>"var"}}, :call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"42"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::VariableExpression.new(:var))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::VariableExpression.new(:var))])
+    @root = :
   end
 
   def test_single_name
-    @string_input = 'my_my.foo(42)'
+    @input = 'my_my.foo(42)'
     @parse_output = {:expression_list=>[{:receiver=>{:name=>"my_my"}, :call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"42"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::NameExpression.new(:my_my))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::NameExpression.new(:my_my))])
+    @root = :
   end
 
   def test_int_receiver
-    @string_input = '42.put()'
+    @input = '42.put()'
     @parse_output = {:expression_list=>[{:receiver=>{:integer=>"42"}, :call_site=>{:name=>"put"}, :argument_list=>[]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:put, [] ,Ast::IntegerExpression.new(42))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:put, [] ,Ast::IntegerExpression.new(42))])
+    @root = :
   end
 
   def test_string_receiver
-    @string_input = '"hello".puts()'
+    @input = '"hello".puts()'
     @parse_output = {:expression_list=>[{:receiver=>{:string=>[{:char=>"h"}, {:char=>"e"}, {:char=>"l"}, {:char=>"l"}, {:char=>"o"}]}, :call_site=>{:name=>"puts"}, :argument_list=>[]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [] ,Ast::StringExpression.new("hello"))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [] ,Ast::StringExpression.new("hello"))])
+    @root = :
   end
 
   def test_single_class
-    @string_input = 'Object.foo(42)'
+    @input = 'Object.foo(42)'
     @parse_output = {:expression_list=>[{:receiver=>{:module_name=>"Object"}, :call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"42"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::ModuleName.new(:Object))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::ModuleName.new(:Object))])
+    @root = :
   end
 
   def test_call_site_multi
-    @string_input = 'baz(42, foo)'
+    @input = 'baz(42, foo)'
     @parse_output = {:expression_list=>[{:call_site=>{:name=>"baz"}, :argument_list=>[{:argument=>{:integer=>"42"}}, {:argument=>{:name=>"foo"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:baz, [Ast::IntegerExpression.new(42),Ast::NameExpression.new(:foo)] ,Ast::NameExpression.new(:self))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:baz, [Ast::IntegerExpression.new(42),Ast::NameExpression.new(:foo)] ,Ast::NameExpression.new(:self))])
+    @root = :
   end
 
   def test_call_site_string
-    @string_input    = 'puts( "hello")'
+    @input    = 'puts( "hello")'
     @parse_output = {:expression_list=>[{:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:string=>[{:char=>"h"}, {:char=>"e"}, {:char=>"l"}, {:char=>"l"}, {:char=>"o"}]}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [Ast::StringExpression.new("hello")] ,Ast::NameExpression.new(:self))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [Ast::StringExpression.new("hello")] ,Ast::NameExpression.new(:self))])
+    @root = :
   end
 
   def test_call_operator
-    @string_input    = 'puts( 3 + 5)'
+    @input    = 'puts( 3 + 5)'
     @parse_output = {:expression_list=>[{:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+ ", :r=>{:integer=>"5"}}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(5))] ,Ast::NameExpression.new(:self))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(5))] ,Ast::NameExpression.new(:self))])
+    @root = :
   end
 
   def test_call_two_operators
-    @string_input    = 'puts(3 + 5 , a - 3)'
+    @input    = 'puts(3 + 5 , a - 3)'
     @parse_output = {:expression_list=>[{:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+ ", :r=>{:integer=>"5"}}}, {:argument=>{:l=>{:name=>"a"}, :o=>"- ", :r=>{:integer=>"3"}}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::IntegerExpression.new(3))] ,Ast::NameExpression.new(:self))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::IntegerExpression.new(3))] ,Ast::NameExpression.new(:self))])
+    @root = :
   end
 
   def test_call_chaining
-    @string_input    = 'puts(putint(3 + 5 ), a - 3)'
+    @input    = 'puts(putint(3 + 5 ), a - 3)'
     @parse_output = {:expression_list=>[{:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:call_site=>{:name=>"putint"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+ ", :r=>{:integer=>"5"}}}]}}, {:argument=>{:l=>{:name=>"a"}, :o=>"- ", :r=>{:integer=>"3"}}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [Ast::CallSiteExpression.new(:putint, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(5))] ,Ast::NameExpression.new(:self)),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::IntegerExpression.new(3))] ,Ast::NameExpression.new(:self))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [Ast::CallSiteExpression.new(:putint, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(5))] ,Ast::NameExpression.new(:self)),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::IntegerExpression.new(3))] ,Ast::NameExpression.new(:self))])
+    @root = :
   end
 
   def test_call_chaining_name
-    @string_input    = 'puts(name.putint(4), a)'
+    @input    = 'puts(name.putint(4), a)'
     @parse_output = {:expression_list=>[{:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:receiver=>{:name=>"name"}, :call_site=>{:name=>"putint"}, :argument_list=>[{:argument=>{:integer=>"4"}}]}}, {:argument=>{:name=>"a"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [Ast::CallSiteExpression.new(:putint, [Ast::IntegerExpression.new(4)] ,Ast::NameExpression.new(:name)),Ast::NameExpression.new(:a)] ,Ast::NameExpression.new(:self))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:puts, [Ast::CallSiteExpression.new(:putint, [Ast::IntegerExpression.new(4)] ,Ast::NameExpression.new(:name)),Ast::NameExpression.new(:a)] ,Ast::NameExpression.new(:self))])
+    @root = :
   end
 
   def test_call_chaining_class
-    @string_input    = 'Class.new(self.get(4))'
+    @input    = 'Class.new(self.get(4))'
     @parse_output = {:expression_list=>[{:receiver=>{:module_name=>"Class"}, :call_site=>{:name=>"new"}, :argument_list=>[{:argument=>{:receiver=>{:name=>"self"}, :call_site=>{:name=>"get"}, :argument_list=>[{:argument=>{:integer=>"4"}}]}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:new, [Ast::CallSiteExpression.new(:get, [Ast::IntegerExpression.new(4)] ,Ast::NameExpression.new(:self))] ,Ast::ModuleName.new(:Class))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:new, [Ast::CallSiteExpression.new(:get, [Ast::IntegerExpression.new(4)] ,Ast::NameExpression.new(:self))] ,Ast::ModuleName.new(:Class))])
+    @root = :
   end
   def test_call_chaining_instance
-    @string_input    = '@class.new(self.get(4))'
+    @input    = '@class.new(self.get(4))'
     @parse_output = {:expression_list=>[{:receiver=>{:instance_variable=>{:name=>"class"}}, :call_site=>{:name=>"new"}, :argument_list=>[{:argument=>{:receiver=>{:name=>"self"}, :call_site=>{:name=>"get"}, :argument_list=>[{:argument=>{:integer=>"4"}}]}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:new, [Ast::CallSiteExpression.new(:get, [Ast::IntegerExpression.new(4)] ,Ast::NameExpression.new(:self))] ,Ast::VariableExpression.new(:class))])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::CallSiteExpression.new(:new, [Ast::CallSiteExpression.new(:get, [Ast::IntegerExpression.new(4)] ,Ast::NameExpression.new(:self))] ,Ast::VariableExpression.new(:class))])
+    @root = :
   end
 
 end

test/roots/test_class.rb

@@ -5,17 +5,17 @@ class RootTestClassDef < MiniTest::Test
   include ParserHelper
   
   def test_simplest_class
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Foo
   5
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Foo", :derived_name=>nil, :class_expressions=>[{:integer=>"5"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Foo ,nil, [Ast::IntegerExpression.new(5)] )])
+    @output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Foo ,nil, [Ast::IntegerExpression.new(5)] )])
   end
 
   def test_class_ops
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Opers
   def foo(x)
     @abba = 5 
@@ -24,11 +24,11 @@ class Opers
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Opers", :derived_name=>nil, :class_expressions=>[{:function_name=>{:name=>"foo"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:l=>{:instance_variable=>{:name=>"abba"}}, :o=>"= ", :r=>{:integer=>"5"}}, {:l=>{:integer=>"2"}, :o=>"+ ", :r=>{:integer=>"5"}}], :end=>"end"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Opers ,nil, [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::VariableExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )] )])
+    @output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Opers ,nil, [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::VariableExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )] )])
   end
 
   def test_class_if
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Ifi
   def ofthen(n)
     if(0)
@@ -40,11 +40,11 @@ class Ifi
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Ifi", :derived_name=>nil, :class_expressions=>[{:function_name=>{:name=>"ofthen"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:if=>"if", :conditional=>{:integer=>"0"}, :if_true=>{:expressions=>[{:l=>{:name=>"isit"}, :o=>"= ", :r=>{:integer=>"42"}}], :else=>"else"}, :if_false=>{:expressions=>[{:l=>{:name=>"maybenot"}, :o=>"= ", :r=>{:integer=>"667"}}], :end=>"end"}}], :end=>"end"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Ifi ,nil, [Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )] )])
+    @output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Ifi ,nil, [Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )] )])
   end
 
   def test_class_function
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Pifi
   ofthen(3+4 , var)
   def ofthen(n,m)
@@ -53,10 +53,10 @@ class Pifi
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Pifi", :derived_name=>nil, :class_expressions=>[{:call_site=>{:name=>"ofthen"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+", :r=>{:integer=>"4"}}}, {:argument=>{:name=>"var"}}]}, {:function_name=>{:name=>"ofthen"}, :parameter_list=>[{:parameter=>{:name=>"n"}}, {:parameter=>{:name=>"m"}}], :expressions=>[{:integer=>"44"}], :end=>"end"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Pifi ,nil, [Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self)), Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n),Ast::NameExpression.new(:m)] , [Ast::IntegerExpression.new(44)] ,nil )] )])
+    @output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Pifi ,nil, [Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self)), Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n),Ast::NameExpression.new(:m)] , [Ast::IntegerExpression.new(44)] ,nil )] )])
   end
   def test_class_module
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Foo
   module Boo
     funcall(3+4 , var)
@@ -64,19 +64,19 @@ class Foo
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Foo", :derived_name=>nil, :class_expressions=>[{:module_name=>"Boo", :module_expressions=>[{:call_site=>{:name=>"funcall"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+", :r=>{:integer=>"4"}}}, {:argument=>{:name=>"var"}}]}], :end=>"end"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Foo ,nil, [Ast::ModuleExpression.new(:Boo ,[Ast::CallSiteExpression.new(:funcall, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )] )])
+    @output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Foo ,nil, [Ast::ModuleExpression.new(:Boo ,[Ast::CallSiteExpression.new(:funcall, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )] )])
   end
   def test_class_derived
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Foo < Object
   ofthen(3+4 , var)
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Foo", :derived_name=>{:module_name=>"Object"}, :class_expressions=>[{:call_site=>{:name=>"ofthen"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+", :r=>{:integer=>"4"}}}, {:argument=>{:name=>"var"}}]}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Foo ,:Object, [Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )])
+    @output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Foo ,:Object, [Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )])
   end
   def test_class_method
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Foo < Object
   def Foo.test()
     43
@@ -84,7 +84,7 @@ class Foo < Object
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Foo", :derived_name=>{:module_name=>"Object"}, :class_expressions=>[{:receiver=>{:module_name=>"Foo"}, :function_name=>{:name=>"test"}, :parameter_list=>[], :expressions=>[{:integer=>"43"}], :end=>"end"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Foo ,:Object, [Ast::FunctionExpression.new(:test, [] , [Ast::IntegerExpression.new(43)] ,Ast::ModuleName.new(:Foo) )] )])
+    @output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Foo ,:Object, [Ast::FunctionExpression.new(:test, [] , [Ast::IntegerExpression.new(43)] ,Ast::ModuleName.new(:Foo) )] )])
   end
   
 end

test/roots/test_compound.rb

@@ -5,39 +5,39 @@ class RootTestCompound < MiniTest::Test
   include ParserHelper
     
   def test_one_array
-    @string_input    = '[42]'
+    @input    = '[42]'
     @parse_output = {:expression_list=>[{:array_constant=>[{:array_element=>{:integer=>"42"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ArrayExpression.new([Ast::IntegerExpression.new(42)])])
+    @output = Ast::ExpressionList.new( [Ast::ArrayExpression.new([Ast::IntegerExpression.new(42)])])
   end
 
   def test_array_list
-    @string_input    = '[42, foo]'
+    @input    = '[42, foo]'
     @parse_output = {:expression_list=>[{:array_constant=>[{:array_element=>{:integer=>"42"}}, {:array_element=>{:name=>"foo"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ArrayExpression.new([Ast::IntegerExpression.new(42), Ast::NameExpression.new(:foo)])])
+    @output = Ast::ExpressionList.new( [Ast::ArrayExpression.new([Ast::IntegerExpression.new(42), Ast::NameExpression.new(:foo)])])
   end
 
   def test_array_ops
-    @string_input    = '[ 3 + 4 , foo(22) ]'
+    @input    = '[ 3 + 4 , foo(22) ]'
     @parse_output = {:expression_list=>[{:array_constant=>[{:array_element=>{:l=>{:integer=>"3"}, :o=>"+ ", :r=>{:integer=>"4"}}}, {:array_element=>{:call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"22"}}]}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ArrayExpression.new([Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)), Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(22)] ,Ast::NameExpression.new(:self))])])
+    @output = Ast::ExpressionList.new( [Ast::ArrayExpression.new([Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)), Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(22)] ,Ast::NameExpression.new(:self))])])
   end
 
   def test_hash
-    @string_input = '{ foo => 33 }'
+    @input = '{ foo => 33 }'
     @parse_output = {:expression_list=>[{:hash_constant=>[{:hash_pair=>{:hash_key=>{:name=>"foo"}, :hash_value=>{:integer=>"33"}}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::HashExpression.new([Ast::AssociationExpression.new(Ast::NameExpression.new(:foo) , Ast::IntegerExpression.new(33))])])
+    @output = Ast::ExpressionList.new( [Ast::HashExpression.new([Ast::AssociationExpression.new(Ast::NameExpression.new(:foo) , Ast::IntegerExpression.new(33))])])
   end
 
   def test_hash2
-    @string_input = '{ foo => true }'
+    @input = '{ foo => true }'
     @parse_output = {:expression_list=>[{:hash_constant=>[{:hash_pair=>{:hash_key=>{:name=>"foo"}, :hash_value=>{:true=>"true"}}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::HashExpression.new([Ast::AssociationExpression.new(Ast::NameExpression.new(:foo) , Ast::TrueExpression.new())])])
+    @output = Ast::ExpressionList.new( [Ast::HashExpression.new([Ast::AssociationExpression.new(Ast::NameExpression.new(:foo) , Ast::TrueExpression.new())])])
   end
 
   def test_hash_list
-    @string_input = "{foo => 33 , bar => 42}"
+    @input = "{foo => 33 , bar => 42}"
     @parse_output = {:expression_list=>[{:hash_constant=>[{:hash_pair=>{:hash_key=>{:name=>"foo"}, :hash_value=>{:integer=>"33"}}}, {:hash_pair=>{:hash_key=>{:name=>"bar"}, :hash_value=>{:integer=>"42"}}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::HashExpression.new([Ast::AssociationExpression.new(Ast::NameExpression.new(:foo) , Ast::IntegerExpression.new(33)), Ast::AssociationExpression.new(Ast::NameExpression.new(:bar) , Ast::IntegerExpression.new(42))])])
+    @output = Ast::ExpressionList.new( [Ast::HashExpression.new([Ast::AssociationExpression.new(Ast::NameExpression.new(:foo) , Ast::IntegerExpression.new(33)), Ast::AssociationExpression.new(Ast::NameExpression.new(:bar) , Ast::IntegerExpression.new(42))])])
   end
 
 end

test/roots/test_conditional.rb

@@ -5,7 +5,7 @@ class RootTestConditional < MiniTest::Test
   include ParserHelper
 
   def test_if_else
-    @string_input = <<HERE
+    @input = <<HERE
 if(0)
   42
 else
@@ -13,57 +13,57 @@ else
 end
 HERE
     @parse_output = {:expression_list=>[{:if=>"if", :conditional=>{:integer=>"0"}, :if_true=>{:expressions=>[{:integer=>"42"}], :else=>"else"}, :if_false=>{:expressions=>[{:integer=>"667"}], :end=>"end"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::IntegerExpression.new(42)],[Ast::IntegerExpression.new(667)] )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::IntegerExpression.new(42)],[Ast::IntegerExpression.new(667)] )])
+    @root = :
   end
 
   def test_if_else_expressions
-    @string_input = <<HERE
+    @input = <<HERE
 if(3 > var)
   Object.initialize(3)
 else
   var.new(33)
 end
 HERE
-    @string_input
+    @input
     @parse_output = {:expression_list=>[{:if=>"if", :conditional=>{:l=>{:integer=>"3"}, :o=>"> ", :r=>{:name=>"var"}}, :if_true=>{:expressions=>[{:receiver=>{:module_name=>"Object"}, :call_site=>{:name=>"initialize"}, :argument_list=>[{:argument=>{:integer=>"3"}}]}], :else=>"else"}, :if_false=>{:expressions=>[{:receiver=>{:name=>"var"}, :call_site=>{:name=>"new"}, :argument_list=>[{:argument=>{:integer=>"33"}}]}], :end=>"end"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::OperatorExpression.new(">", Ast::IntegerExpression.new(3),Ast::NameExpression.new(:var)), [Ast::CallSiteExpression.new(:initialize, [Ast::IntegerExpression.new(3)] ,Ast::ModuleName.new(:Object))],[Ast::CallSiteExpression.new(:new, [Ast::IntegerExpression.new(33)] ,Ast::NameExpression.new(:var))] )])
+    @output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::OperatorExpression.new(">", Ast::IntegerExpression.new(3),Ast::NameExpression.new(:var)), [Ast::CallSiteExpression.new(:initialize, [Ast::IntegerExpression.new(3)] ,Ast::ModuleName.new(:Object))],[Ast::CallSiteExpression.new(:new, [Ast::IntegerExpression.new(33)] ,Ast::NameExpression.new(:var))] )])
   end
 
   def pest_if_end
-    @string_input = <<HERE
+    @input = <<HERE
 if(0)
   42
 end
 HERE
     @parse_output = {:expression_list=>[{:if=>"if", :conditional=>{:integer=>"0"}, :if_true=>{:expressions=>[{:integer=>"42"}], :else=>"else"}, :if_false=>{:expressions=>[{:integer=>"667"}], :end=>"end"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::IntegerExpression.new(42)],[Ast::IntegerExpression.new(667)] )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::IntegerExpression.new(42)],[Ast::IntegerExpression.new(667)] )])
+    @root = :
   end
 
   def pest_if_end_expressions
-    @string_input = <<HERE
+    @input = <<HERE
 if(3 > var)
   Object.initialize(3)
 end
 HERE
-    @string_input
+    @input
     @parse_output = {:expression_list=>[{:if=>"if", :conditional=>{:l=>{:integer=>"3"}, :o=>"> ", :r=>{:name=>"var"}}, :if_true=>{:expressions=>[{:receiver=>{:module_name=>"Object"}, :call_site=>{:name=>"initialize"}, :argument_list=>[{:argument=>{:integer=>"3"}}]}], :else=>"else"}, :if_false=>{:expressions=>[{:receiver=>{:name=>"var"}, :call_site=>{:name=>"new"}, :argument_list=>[{:argument=>{:integer=>"33"}}]}], :end=>"end"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::OperatorExpression.new(">", Ast::IntegerExpression.new(3),Ast::NameExpression.new(:var)), [Ast::CallSiteExpression.new(:initialize, [Ast::IntegerExpression.new(3)] ,Ast::ModuleName.new(:Object))],[Ast::CallSiteExpression.new(:new, [Ast::IntegerExpression.new(33)] ,Ast::NameExpression.new(:var))] )])
+    @output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::OperatorExpression.new(">", Ast::IntegerExpression.new(3),Ast::NameExpression.new(:var)), [Ast::CallSiteExpression.new(:initialize, [Ast::IntegerExpression.new(3)] ,Ast::ModuleName.new(:Object))],[Ast::CallSiteExpression.new(:new, [Ast::IntegerExpression.new(33)] ,Ast::NameExpression.new(:var))] )])
   end
 
   def pest_if_reverse
-    @string_input = "42  if(0)"
+    @input = "42  if(0)"
     @parse_output = {:expression_list=>[{:if=>"if", :conditional=>{:integer=>"0"}, :if_true=>{:expressions=>[{:integer=>"42"}], :else=>"else"}, :if_false=>{:expressions=>[{:integer=>"667"}], :end=>"end"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::IntegerExpression.new(42)],[Ast::IntegerExpression.new(667)] )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::IntegerExpression.new(42)],[Ast::IntegerExpression.new(667)] )])
+    @root = :
   end
 
   def pest_if_end_expressions
-    @string_input = "Object.initialize(3)  if(3 > var)"
-    @string_input
+    @input = "Object.initialize(3)  if(3 > var)"
+    @input
     @parse_output = {:expression_list=>[{:if=>"if", :conditional=>{:l=>{:integer=>"3"}, :o=>"> ", :r=>{:name=>"var"}}, :if_true=>{:expressions=>[{:receiver=>{:module_name=>"Object"}, :call_site=>{:name=>"initialize"}, :argument_list=>[{:argument=>{:integer=>"3"}}]}], :else=>"else"}, :if_false=>{:expressions=>[{:receiver=>{:name=>"var"}, :call_site=>{:name=>"new"}, :argument_list=>[{:argument=>{:integer=>"33"}}]}], :end=>"end"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::OperatorExpression.new(">", Ast::IntegerExpression.new(3),Ast::NameExpression.new(:var)), [Ast::CallSiteExpression.new(:initialize, [Ast::IntegerExpression.new(3)] ,Ast::ModuleName.new(:Object))],[Ast::CallSiteExpression.new(:new, [Ast::IntegerExpression.new(33)] ,Ast::NameExpression.new(:var))] )])
+    @output = Ast::ExpressionList.new( [Ast::IfExpression.new(Ast::OperatorExpression.new(">", Ast::IntegerExpression.new(3),Ast::NameExpression.new(:var)), [Ast::CallSiteExpression.new(:initialize, [Ast::IntegerExpression.new(3)] ,Ast::ModuleName.new(:Object))],[Ast::CallSiteExpression.new(:new, [Ast::IntegerExpression.new(33)] ,Ast::NameExpression.new(:var))] )])
   end
 
 

test/roots/test_function_definition.rb

@@ -5,75 +5,75 @@ class RootTestFunctionDefinition < MiniTest::Test
   include ParserHelper
 
   def test_simplest_function
-    @string_input    = <<HERE
+    @input    = <<HERE
 def foo(x)
   5
 end
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"foo"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:integer=>"5"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::IntegerExpression.new(5)] ,nil )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::IntegerExpression.new(5)] ,nil )])
+    @root = :
   end
 
   def test_function_no_braces
-    @string_input    = <<HERE
+    @input    = <<HERE
 def foo
   5
 end
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"foo"}, :expressions=>[{:integer=>"5"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [] , [Ast::IntegerExpression.new(5)] ,nil )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [] , [Ast::IntegerExpression.new(5)] ,nil )])
+    @root = :
   end
 
   def pest_function_no_braces_and_args
-    @string_input    = <<HERE
+    @input    = <<HERE
 def foo n , m
   n
 end
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"foo"}, :expressions=>[{:name=>"n"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [] , [Ast::NameExpression.new(:n)] ,nil )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [] , [Ast::NameExpression.new(:n)] ,nil )])
+    @root = :
   end
 
   def test_class_function
-    @string_input    = <<HERE
+    @input    = <<HERE
 def String.length(x)
   @length
 end
 HERE
     @parse_output = {:expression_list=>[{:receiver=>{:module_name=>"String"}, :function_name=>{:name=>"length"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:instance_variable=>{:name=>"length"}}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:length, [Ast::NameExpression.new(:x)] , [Ast::VariableExpression.new(:length)] ,Ast::ModuleName.new(:String) )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:length, [Ast::NameExpression.new(:x)] , [Ast::VariableExpression.new(:length)] ,Ast::ModuleName.new(:String) )])
+    @root = :
   end
 
   def pest_function_default_args
-    @string_input    = <<HERE
+    @input    = <<HERE
 def foo(x = true )
  abba = 5
  2 + 5
 end
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"foo"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:l=>{:name=>"abba"}, :o=>"= ", :r=>{:integer=>"5"}}, {:l=>{:integer=>"2"}, :o=>"+ ", :r=>{:integer=>"5"}}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )])
+    @root = :
   end
 
   def test_function_ops
-    @string_input    = <<HERE
+    @input    = <<HERE
 def foo(x)
  abba = 5
  2 + 5
 end
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"foo"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:l=>{:name=>"abba"}, :o=>"= ", :r=>{:integer=>"5"}}, {:l=>{:integer=>"2"}, :o=>"+ ", :r=>{:integer=>"5"}}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )])
+    @root = :
   end
 
   def test_function_if
-    @string_input    = <<HERE
+    @input    = <<HERE
 def ofthen(n)
   if(0)
     isit = 42
@@ -83,24 +83,24 @@ def ofthen(n)
 end
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"ofthen"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:if=>"if", :conditional=>{:integer=>"0"}, :if_true=>{:expressions=>[{:l=>{:name=>"isit"}, :o=>"= ", :r=>{:integer=>"42"}}], :else=>"else"}, :if_false=>{:expressions=>[{:l=>{:name=>"maybenot"}, :o=>"= ", :r=>{:integer=>"667"}}], :end=>"end"}}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )])
+    @root = :
   end
 
   def test_function_return
-    @string_input    = <<HERE
+    @input    = <<HERE
 def retvar(n)
   i = 5
   return i
 end
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"retvar"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:l=>{:name=>"i"}, :o=>"= ", :r=>{:integer=>"5"}}, {:return=>"return", :return_expression=>{:name=>"i"}}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:i),Ast::IntegerExpression.new(5)),Ast::ReturnExpression.new(Ast::NameExpression.new(:i) )] ,nil )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:i),Ast::IntegerExpression.new(5)),Ast::ReturnExpression.new(Ast::NameExpression.new(:i) )] ,nil )])
+    @root = :
   end
 
   def test_function_return_if
-    @string_input    = <<HERE
+    @input    = <<HERE
 def retvar(n)
   if( n > 5)
     return 10
@@ -110,12 +110,12 @@ def retvar(n)
 end
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"retvar"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:if=>"if", :conditional=>{:l=>{:name=>"n"}, :o=>"> ", :r=>{:integer=>"5"}}, :if_true=>{:expressions=>[{:return=>"return", :return_expression=>{:integer=>"10"}}], :else=>"else"}, :if_false=>{:expressions=>[{:return=>"return", :return_expression=>{:integer=>"20"}}], :end=>"end"}}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(5)), [Ast::ReturnExpression.new(Ast::IntegerExpression.new(10) )],[Ast::ReturnExpression.new(Ast::IntegerExpression.new(20) )] )] ,nil )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(5)), [Ast::ReturnExpression.new(Ast::IntegerExpression.new(10) )],[Ast::ReturnExpression.new(Ast::IntegerExpression.new(20) )] )] ,nil )])
+    @root = :
   end
 
   def test_function_return_while
-    @string_input    = <<HERE
+    @input    = <<HERE
 def retvar(n)
   while( n > 5) do
     n = n + 1
@@ -124,12 +124,12 @@ def retvar(n)
 end
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"retvar"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:while=>"while", :while_cond=>{:l=>{:name=>"n"}, :o=>"> ", :r=>{:integer=>"5"}}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"n"}, :o=>"= ", :r=>{:l=>{:name=>"n"}, :o=>"+ ", :r=>{:integer=>"1"}}}, {:return=>"return", :return_expression=>{:name=>"n"}}], :end=>"end"}}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new(:n)] , [Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(5)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1))), Ast::ReturnExpression.new(Ast::NameExpression.new(:n) )] )] ,nil )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new(:n)] , [Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(5)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1))), Ast::ReturnExpression.new(Ast::NameExpression.new(:n) )] )] ,nil )])
+    @root = :
   end
 
   def test_function_while
-    @string_input    = <<HERE
+    @input    = <<HERE
 def fibonaccit(n)
   a = 0
   while (n) do
@@ -139,12 +139,12 @@ def fibonaccit(n)
 end
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"fibonaccit"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:l=>{:name=>"a"}, :o=>"= ", :r=>{:integer=>"0"}}, {:while=>"while", :while_cond=>{:name=>"n"}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"some"}, :o=>"= ", :r=>{:integer=>"43"}}, {:l=>{:name=>"other"}, :o=>"= ", :r=>{:l=>{:name=>"some"}, :o=>"* ", :r=>{:integer=>"4"}}}], :end=>"end"}}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::WhileExpression.new(Ast::NameExpression.new(:n), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:some),Ast::IntegerExpression.new(43)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:other),Ast::OperatorExpression.new("*", Ast::NameExpression.new(:some),Ast::IntegerExpression.new(4)))] )] ,nil )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::WhileExpression.new(Ast::NameExpression.new(:n), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:some),Ast::IntegerExpression.new(43)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:other),Ast::OperatorExpression.new("*", Ast::NameExpression.new(:some),Ast::IntegerExpression.new(4)))] )] ,nil )])
+    @root = :
   end
 
   def test_function_big_while
-    @string_input    = <<HERE
+    @input    = <<HERE
 def fibonaccit(n)
   a = 0
   b = 1
@@ -158,7 +158,7 @@ def fibonaccit(n)
 end
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"fibonaccit"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:l=>{:name=>"a"}, :o=>"= ", :r=>{:integer=>"0"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:integer=>"1"}}, {:while=>"while", :while_cond=>{:l=>{:name=>"n"}, :o=>"> ", :r=>{:integer=>"1"}}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:l=>{:name=>"a"}, :o=>"= ", :r=>{:name=>"b"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:l=>{:name=>"tmp"}, :o=>"+ ", :r=>{:name=>"b"}}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}, {:l=>{:name=>"n"}, :o=>"= ", :r=>{:l=>{:name=>"n"}, :o=>"- ", :r=>{:integer=>"1"}}}], :end=>"end"}}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::IntegerExpression.new(1)),Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )] ,nil )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::IntegerExpression.new(1)),Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )] ,nil )])
+    @root = :
   end
 end

test/roots/test_module.rb

@@ -5,17 +5,17 @@ class RootTestModuleDef < MiniTest::Test
   include ParserHelper
   
   def test_simplest_module
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Simple
   5
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Simple", :module_expressions=>[{:integer=>"5"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Simple ,[Ast::IntegerExpression.new(5)] )])
+    @output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Simple ,[Ast::IntegerExpression.new(5)] )])
   end
 
   def test_module_ops
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Opers
   def foo(x)
     abba = 5
@@ -24,21 +24,21 @@ module Opers
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Opers", :module_expressions=>[{:function_name=>{:name=>"foo"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:l=>{:name=>"abba"}, :o=>"= ", :r=>{:integer=>"5"}}, {:l=>{:integer=>"2"}, :o=>"+ ", :r=>{:integer=>"5"}}], :end=>"end"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Opers ,[Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )] )])
+    @output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Opers ,[Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )] )])
   end
 
   def test_module_assign_instance
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Opers
   @abba = 5
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Opers", :module_expressions=>[{:l=>{:instance_variable=>{:name=>"abba"}}, :o=>"= ", :r=>{:integer=>"5"}}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Opers ,[Ast::AssignmentExpression.new(Ast::VariableExpression.new(:abba),Ast::IntegerExpression.new(5))] )])
+    @output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Opers ,[Ast::AssignmentExpression.new(Ast::VariableExpression.new(:abba),Ast::IntegerExpression.new(5))] )])
   end
 
   def test_module_if
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Foo
   def ofthen(n)
     if(0)
@@ -50,11 +50,11 @@ module Foo
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Foo", :module_expressions=>[{:function_name=>{:name=>"ofthen"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:if=>"if", :conditional=>{:integer=>"0"}, :if_true=>{:expressions=>[{:l=>{:name=>"isit"}, :o=>"= ", :r=>{:integer=>"42"}}], :else=>"else"}, :if_false=>{:expressions=>[{:l=>{:name=>"maybenot"}, :o=>"= ", :r=>{:integer=>"667"}}], :end=>"end"}}], :end=>"end"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Foo ,[Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )] )])
+    @output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Foo ,[Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )] )])
   end
 
   def test_module_function
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Soho
   ofthen(3+4 , var)
   def ofthen(n,m)
@@ -63,11 +63,11 @@ module Soho
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Soho", :module_expressions=>[{:call_site=>{:name=>"ofthen"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+", :r=>{:integer=>"4"}}}, {:argument=>{:name=>"var"}}]}, {:function_name=>{:name=>"ofthen"}, :parameter_list=>[{:parameter=>{:name=>"n"}}, {:parameter=>{:name=>"m"}}], :expressions=>[{:integer=>"44"}], :end=>"end"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Soho ,[Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self)), Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n),Ast::NameExpression.new(:m)] , [Ast::IntegerExpression.new(44)] ,nil )] )])
+    @output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Soho ,[Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self)), Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n),Ast::NameExpression.new(:m)] , [Ast::IntegerExpression.new(44)] ,nil )] )])
   end
 
   def test_function_without_braces
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Foo
   def bar
     4
@@ -75,11 +75,11 @@ class Foo
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Foo", :derived_name=>nil, :class_expressions=>[{:function_name=>{:name=>"bar"}, :expressions=>[{:integer=>"4"}], :end=>"end"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Foo ,nil, [Ast::FunctionExpression.new(:bar, [] , [Ast::IntegerExpression.new(4)] ,nil )] )])
+    @output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:Foo ,nil, [Ast::FunctionExpression.new(:bar, [] , [Ast::IntegerExpression.new(4)] ,nil )] )])
   end
 
   def test_module_class
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Foo
   class Bar
     funcall(3+4 , var)
@@ -87,6 +87,6 @@ module Foo
 end
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Foo", :module_expressions=>[{:module_name=>"Bar", :derived_name=>nil, :class_expressions=>[{:call_site=>{:name=>"funcall"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+", :r=>{:integer=>"4"}}}, {:argument=>{:name=>"var"}}]}], :end=>"end"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Foo ,[Ast::ClassExpression.new(:Bar ,nil, [Ast::CallSiteExpression.new(:funcall, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )] )])
+    @output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Foo ,[Ast::ClassExpression.new(:Bar ,nil, [Ast::CallSiteExpression.new(:funcall, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )] )])
   end
 end

test/roots/test_operators.rb

@@ -5,9 +5,9 @@ class RootTestExpressions < MiniTest::Test
   include ParserHelper
 
   def simple_op op
-    @string_input    = "5 #{op} 3"
+    @input    = "5 #{op} 3"
     @parse_output = {:expression_list=>[{:l=>{:integer=>"5"}, :o=>"#{op} ", :r=>{:integer=>"3"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::OperatorExpression.new(op, Ast::IntegerExpression.new(5),Ast::IntegerExpression.new(3))])
+    @output = Ast::ExpressionList.new( [Ast::OperatorExpression.new(op, Ast::IntegerExpression.new(5),Ast::IntegerExpression.new(3))])
   end
   def test_simple_multiply
     simple_op "*"
@@ -28,54 +28,54 @@ class RootTestExpressions < MiniTest::Test
     simple_op "<"
   end
   def test_op_variable
-    @string_input    = "a + 35"
+    @input    = "a + 35"
     @parse_output = {:expression_list=>[{:l=>{:name=>"a"}, :o=>"+ ", :r=>{:integer=>"35"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("+", Ast::NameExpression.new(:a),Ast::IntegerExpression.new(35))])
+    @output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("+", Ast::NameExpression.new(:a),Ast::IntegerExpression.new(35))])
   end
   def test_op_two_variable
-    @string_input    = "a - b"
+    @input    = "a - b"
     @parse_output = {:expression_list=>[{:l=>{:name=>"a"}, :o=>"- ", :r=>{:name=>"b"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::NameExpression.new(:b))])
+    @output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::NameExpression.new(:b))])
   end
   def test_op_instance_variable
-    @string_input    = "@a - 5"
+    @input    = "@a - 5"
     @parse_output = {:expression_list=>[{:l=>{:instance_variable=>{:name=>"a"}}, :o=>"- ", :r=>{:integer=>"5"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("-", Ast::VariableExpression.new(:a),Ast::IntegerExpression.new(5))])
+    @output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("-", Ast::VariableExpression.new(:a),Ast::IntegerExpression.new(5))])
   end
   def test_op_variable_string
-    @string_input    = 'a - "st"'
+    @input    = 'a - "st"'
     @parse_output = {:expression_list=>[{:l=>{:name=>"a"}, :o=>"- ", :r=>{:string=>[{:char=>"s"}, {:char=>"t"}]}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::StringExpression.new("st"))])
+    @output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::StringExpression.new("st"))])
   end
   def test_op_variable_true
-    @string_input    = 'a == true'
+    @input    = 'a == true'
     @parse_output = {:expression_list=>[{:l=>{:name=>"a"}, :o=>"== ", :r=>{:true=>"true"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("==", Ast::NameExpression.new(:a),Ast::TrueExpression.new())])
+    @output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("==", Ast::NameExpression.new(:a),Ast::TrueExpression.new())])
   end
   def test_two_same_ops
-    @string_input    = '2 + 3 + 4'
+    @input    = '2 + 3 + 4'
     @parse_output = {:expression_list=>[{:l=>{:l=>{:integer=>"2"}, :o=>"+ ", :r=>{:integer=>"3"}}, :o=>"+ ", :r=>{:integer=>"4"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("+", Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(3)),Ast::IntegerExpression.new(4))])
+    @output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("+", Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(3)),Ast::IntegerExpression.new(4))])
   end
   def test_two_different_ops
-    @string_input    = '2 + 3 * 4'
+    @input    = '2 + 3 * 4'
     @parse_output = {:expression_list=>[{:l=>{:integer=>"2"}, :o=>"+ ", :r=>{:l=>{:integer=>"3"}, :o=>"* ", :r=>{:integer=>"4"}}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::OperatorExpression.new("*", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)))])
+    @output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::OperatorExpression.new("*", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)))])
   end
   def test_two_different_ops_order
-    @string_input    = '2 * 3 + 4'
+    @input    = '2 * 3 + 4'
     @parse_output = {:expression_list=>[{:l=>{:l=>{:integer=>"2"}, :o=>"* ", :r=>{:integer=>"3"}}, :o=>"+ ", :r=>{:integer=>"4"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("+", Ast::OperatorExpression.new("*", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(3)),Ast::IntegerExpression.new(4))])
+    @output = Ast::ExpressionList.new( [Ast::OperatorExpression.new("+", Ast::OperatorExpression.new("*", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(3)),Ast::IntegerExpression.new(4))])
   end
   def test_assignment
-    @string_input    = "a = 5"
+    @input    = "a = 5"
     @parse_output = {:expression_list=>[{:l=>{:name=>"a"}, :o=>"= ", :r=>{:integer=>"5"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(5))])
+    @output = Ast::ExpressionList.new( [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(5))])
   end
   def test_assignment_instance
-    @string_input    = "@a = 5"
+    @input    = "@a = 5"
     @parse_output = {:expression_list=>[{:l=>{:instance_variable=>{:name=>"a"}}, :o=>"= ", :r=>{:integer=>"5"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::AssignmentExpression.new(Ast::VariableExpression.new(:a),Ast::IntegerExpression.new(5))])
+    @output = Ast::ExpressionList.new( [Ast::AssignmentExpression.new(Ast::VariableExpression.new(:a),Ast::IntegerExpression.new(5))])
   end
 
 end

test/roots/test_return.rb

@@ -5,21 +5,21 @@ class RootTestReturn < MiniTest::Test
   include ParserHelper
     
   def test_return_int
-    @string_input = 'return 42'
+    @input = 'return 42'
     @parse_output = {:expression_list=>[{:name=>"return"}, {:integer=>"42"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::NameExpression.new(:return),Ast::IntegerExpression.new(42)])
+    @output = Ast::ExpressionList.new( [Ast::NameExpression.new(:return),Ast::IntegerExpression.new(42)])
   end
 
   def test_return_variable
-    @string_input = 'return foo'
+    @input = 'return foo'
     @parse_output = {:expression_list=>[{:name=>"return"}, {:name=>"foo"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::NameExpression.new(:return),Ast::NameExpression.new(:foo)])
+    @output = Ast::ExpressionList.new( [Ast::NameExpression.new(:return),Ast::NameExpression.new(:foo)])
   end
 
   def test_return_string
-    @string_input    = 'return "hello"'
+    @input    = 'return "hello"'
     @parse_output = {:expression_list=>[{:name=>"return"}, {:string=>[{:char=>"h"}, {:char=>"e"}, {:char=>"l"}, {:char=>"l"}, {:char=>"o"}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::NameExpression.new(:return),Ast::StringExpression.new("hello")])
+    @output = Ast::ExpressionList.new( [Ast::NameExpression.new(:return),Ast::StringExpression.new("hello")])
   end
 
 end

test/roots/test_root.rb

@@ -5,7 +5,7 @@ class RootTestRoot < MiniTest::Test
   include ParserHelper
     
   def test_double_root
-    @string_input = <<HERE
+    @input = <<HERE
 def foo(x) 
   a = 5
 end
@@ -13,11 +13,11 @@ end
 foo( 3 )
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"foo"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:l=>{:name=>"a"}, :o=>"= ", :r=>{:integer=>"5"}}], :end=>"end"}, {:call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"3"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(5))] ,nil ),Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(3)] ,Ast::NameExpression.new(:self))])
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(5))] ,nil ),Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(3)] ,Ast::NameExpression.new(:self))])
   end
 
   def test_comments
-    @string_input = <<HERE
+    @input = <<HERE
 def foo(x) #here
   a = 0           # a == r1
   b = 1           # b = r2
@@ -32,11 +32,11 @@ end #anywhere
 foo( 3 ) #and more
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"foo"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:l=>{:name=>"a"}, :o=>"= ", :r=>{:integer=>"0"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:integer=>"1"}}, {:while=>"while", :while_cond=>{:l=>{:name=>"n"}, :o=>"<", :r=>{:integer=>"1"}}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:l=>{:name=>"a"}, :o=>"= ", :r=>{:name=>"b"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:l=>{:name=>"tmp"}, :o=>"+ ", :r=>{:name=>"b"}}}, {:call_site=>{:name=>"putstring"}, :argument_list=>[{:argument=>{:name=>"b"}}]}, {:l=>{:name=>"n"}, :o=>"= ", :r=>{:l=>{:name=>"n"}, :o=>"- ", :r=>{:integer=>"1"}}}], :end=>"end"}}], :end=>"end"}, {:call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"3"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::IntegerExpression.new(1)),Ast::WhileExpression.new(Ast::OperatorExpression.new("<", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:putstring, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )] ,nil ),Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(3)] ,Ast::NameExpression.new(:self))])
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::IntegerExpression.new(1)),Ast::WhileExpression.new(Ast::OperatorExpression.new("<", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:putstring, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )] ,nil ),Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(3)] ,Ast::NameExpression.new(:self))])
   end
 
   def test_fibo1
-    @string_input = <<HERE
+    @input = <<HERE
 def fibonaccit(n)
   a = 0 
   b = 1
@@ -52,11 +52,11 @@ end
 fibonaccit( 10 )
 HERE
     @parse_output = {:expression_list=>[{:function_name=>{:name=>"fibonaccit"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:l=>{:name=>"a"}, :o=>"= ", :r=>{:integer=>"0"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:integer=>"1"}}, {:while=>"while", :while_cond=>{:l=>{:name=>"n"}, :o=>"> ", :r=>{:integer=>"1"}}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:l=>{:name=>"a"}, :o=>"= ", :r=>{:name=>"b"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:l=>{:name=>"tmp"}, :o=>"+ ", :r=>{:name=>"b"}}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}, {:l=>{:name=>"n"}, :o=>"= ", :r=>{:l=>{:name=>"n"}, :o=>"- ", :r=>{:integer=>"1"}}}], :end=>"end"}}], :end=>"end"}, {:call_site=>{:name=>"fibonaccit"}, :argument_list=>[{:argument=>{:integer=>"10"}}]}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::IntegerExpression.new(1)),Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )] ,nil ),Ast::CallSiteExpression.new(:fibonaccit, [Ast::IntegerExpression.new(10)] ,Ast::NameExpression.new(:self))])
+    @output = Ast::ExpressionList.new( [Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::IntegerExpression.new(1)),Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )] ,nil ),Ast::CallSiteExpression.new(:fibonaccit, [Ast::IntegerExpression.new(10)] ,Ast::NameExpression.new(:self))])
   end
   
   def test_module_method
-    @string_input = <<HERE
+    @input = <<HERE
 module Fibo
   def fibonaccit(n)
     a = 0 
@@ -67,11 +67,11 @@ end
 
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Fibo", :module_expressions=>[{:function_name=>{:name=>"fibonaccit"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:l=>{:name=>"a"}, :o=>"= ", :r=>{:integer=>"0"}}], :end=>"end"}, {:call_site=>{:name=>"fibonaccit"}, :argument_list=>[{:argument=>{:integer=>"10"}}]}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Fibo ,[Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0))] ,nil ), Ast::CallSiteExpression.new(:fibonaccit, [Ast::IntegerExpression.new(10)] ,Ast::NameExpression.new(:self))] )])
+    @output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Fibo ,[Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0))] ,nil ), Ast::CallSiteExpression.new(:fibonaccit, [Ast::IntegerExpression.new(10)] ,Ast::NameExpression.new(:self))] )])
   end
 
   def test_module_assignment
-    @string_input = <<HERE
+    @input = <<HERE
 module Fibo
   a = 5 + foo
   bar( b , a , r)
@@ -79,11 +79,11 @@ end
 
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"Fibo", :module_expressions=>[{:l=>{:name=>"a"}, :o=>"= ", :r=>{:l=>{:integer=>"5"}, :o=>"+ ", :r=>{:name=>"foo"}}}, {:call_site=>{:name=>"bar"}, :argument_list=>[{:argument=>{:name=>"b"}}, {:argument=>{:name=>"a"}}, {:argument=>{:name=>"r"}}]}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Fibo ,[Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(5),Ast::NameExpression.new(:foo))), Ast::CallSiteExpression.new(:bar, [Ast::NameExpression.new(:b),Ast::NameExpression.new(:a),Ast::NameExpression.new(:r)] ,Ast::NameExpression.new(:self))] )])
+    @output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:Fibo ,[Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(5),Ast::NameExpression.new(:foo))), Ast::CallSiteExpression.new(:bar, [Ast::NameExpression.new(:b),Ast::NameExpression.new(:a),Ast::NameExpression.new(:r)] ,Ast::NameExpression.new(:self))] )])
   end
 
   def test_root_module_class
-    @string_input = <<HERE
+    @input = <<HERE
 module FooBo
   class Bar
     a = 5 + foo
@@ -92,18 +92,18 @@ end
 
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"FooBo", :module_expressions=>[{:module_name=>"Bar", :derived_name=>nil, :class_expressions=>[{:l=>{:name=>"a"}, :o=>"= ", :r=>{:l=>{:integer=>"5"}, :o=>"+ ", :r=>{:name=>"foo"}}}], :end=>"end"}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:FooBo ,[Ast::ClassExpression.new(:Bar ,nil, [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(5),Ast::NameExpression.new(:foo)))] )] )])
+    @output = Ast::ExpressionList.new( [Ast::ModuleExpression.new(:FooBo ,[Ast::ClassExpression.new(:Bar ,nil, [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(5),Ast::NameExpression.new(:foo)))] )] )])
   end
 
   def test_class_method
-    @string_input = <<HERE
+    @input = <<HERE
 class FooBo
   Bar.call(35)
 end
 
 HERE
     @parse_output = {:expression_list=>[{:module_name=>"FooBo", :derived_name=>nil, :class_expressions=>[{:receiver=>{:module_name=>"Bar"}, :call_site=>{:name=>"call"}, :argument_list=>[{:argument=>{:integer=>"35"}}]}], :end=>"end"}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:FooBo ,nil, [Ast::CallSiteExpression.new(:call, [Ast::IntegerExpression.new(35)] ,Ast::ModuleName.new(:Bar))] )])
+    @output = Ast::ExpressionList.new( [Ast::ClassExpression.new(:FooBo ,nil, [Ast::CallSiteExpression.new(:call, [Ast::IntegerExpression.new(35)] ,Ast::ModuleName.new(:Bar))] )])
   end
 
 end

test/roots/test_while.rb

@@ -5,38 +5,38 @@ class RootTestWhile < MiniTest::Test
   include ParserHelper
 
   def test_while
-    @string_input = <<HERE
+    @input = <<HERE
 while(1) do
   tmp = a
   puts(b)
 end
 HERE
     @parse_output = {:expression_list=>[{:while=>"while", :while_cond=>{:integer=>"1"}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}], :end=>"end"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self))] )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self))] )])
+    @root = :
   end
 
   def pest_while_reverse
-    @string_input =  "puts '1' while true "
+    @input =  "puts '1' while true "
     @parse_output = {:expression_list=>[{:while=>"while", :while_cond=>{:integer=>"1"}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}], :end=>"end"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self))] )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self))] )])
+    @root = :
   end
 
   def test_while_method
-    @string_input = <<HERE
+    @input = <<HERE
 while(1) do
   tmp = String.new()
   tmp.puts(i)
 end
 HERE
     @parse_output = {:expression_list=>[{:while=>"while", :while_cond=>{:integer=>"1"}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:receiver=>{:module_name=>"String"}, :call_site=>{:name=>"new"}, :argument_list=>[]}}, {:receiver=>{:name=>"tmp"}, :call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"i"}}]}], :end=>"end"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::CallSiteExpression.new(:new, [] ,Ast::ModuleName.new(:String))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:i)] ,Ast::NameExpression.new(:tmp))] )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::CallSiteExpression.new(:new, [] ,Ast::ModuleName.new(:String))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:i)] ,Ast::NameExpression.new(:tmp))] )])
+    @root = :
   end
 
   def test_big_while
-    @string_input = <<HERE
+    @input = <<HERE
 while( n > 1) do
   tmp = a
   a = b
@@ -46,7 +46,7 @@ while( n > 1) do
 end
 HERE
     @parse_output = {:expression_list=>[{:while=>"while", :while_cond=>{:l=>{:name=>"n"}, :o=>"> ", :r=>{:integer=>"1"}}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:l=>{:name=>"a"}, :o=>"= ", :r=>{:name=>"b"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:l=>{:name=>"tmp"}, :o=>"+ ", :r=>{:name=>"b"}}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}, {:l=>{:name=>"n"}, :o=>"= ", :r=>{:l=>{:name=>"n"}, :o=>"- ", :r=>{:integer=>"1"}}}], :end=>"end"}}]}
-    @transform_output = Ast::ExpressionList.new( [Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )])
-    @parser = @parser
+    @output = Ast::ExpressionList.new( [Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )])
+    @root = :
   end
 end

test/setup.rb

@@ -8,15 +8,12 @@ rescue Bundler::BundlerError => e
   $stderr.puts "Run `bundle install` to install missing gems"
   exit e.status_code
 end
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
 
 require 'salama-reader'
 
 require "minitest"
 require "minitest/autorun"
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'test'))
-

test/test_all.rb

@@ -1,2 +1,2 @@
 require_relative "unit/test_all"
-require_relative "roots/test_all"
+#require_relative "roots/test_all"

test/unit/test_all.rb

@@ -1,13 +1,13 @@
 
-require_relative "test_arguments"
+#require_relative "test_arguments"
 require_relative "test_basic"
 require_relative "test_call_site"
-require_relative "test_class"
-require_relative "test_compound"
+#require_relative "test_class"
+#require_relative "test_compound"
 require_relative "test_conditional"
-require_relative "test_expressions"
-require_relative "test_function_definition"
-require_relative "test_module"
-require_relative "test_operators"
-require_relative "test_return"
-require_relative "test_while"
+#require_relative "test_expressions"
+#require_relative "test_function_definition"
+#require_relative "test_module"
+#require_relative "test_operators"
+#require_relative "test_return"
+#require_relative "test_while"

test/unit/test_arguments.rb

@@ -5,33 +5,33 @@ class TestArguments < MiniTest::Test
   include ParserHelper
     
   def test_one_argument
-    @string_input    = '(42)'
+    @input    = '(42)'
     @parse_output = {:argument_list => [{:argument => {:integer => '42'}}] }
-    @transform_output =  [Ast::IntegerExpression.new(42) ]
-    @parser = @parser.argument_list
+    @output =  [Ast::IntegerExpression.new(42) ]
+    @root = :argument_list
   end
 
   def test_argument_list
-    @string_input    = '(42, foo)'
+    @input    = '(42, foo)'
     @parse_output = {:argument_list => [{:argument => {:integer => '42'}},
                                       {:argument => {:name   => 'foo'}}]}
-    @transform_output = [Ast::IntegerExpression.new(42), Ast::NameExpression.new('foo')]
-    @parser = @parser.argument_list
+    @output = [Ast::IntegerExpression.new(42), Ast::NameExpression.new('foo')]
+    @root = :argument_list
   end
 
   def test_parameter
-    @string_input = "(foo)"
+    @input = "(foo)"
     @parse_output = {:parameter_list=>[{:parameter=>{:name=>"foo"}}]}
-    @transform_output = [Ast::NameExpression.new('foo')]
-    @parser = @parser.parameter_list
+    @output = [Ast::NameExpression.new('foo')]
+    @root = :parameter_list
   end
 
   def test_parameter_list
-    @string_input = "( foo , bar)"
+    @input = "( foo , bar)"
     @parse_output = {:parameter_list => [{:parameter => { :name => "foo"}},
                                         {:parameter => { :name => "bar"}} ]}
-    @transform_output = [Ast::NameExpression.new('foo') , Ast::NameExpression.new('bar')]
-    @parser = @parser.parameter_list
+    @output = [Ast::NameExpression.new('foo') , Ast::NameExpression.new('bar')]
+    @root = :parameter_list
   end
 
 end

test/unit/test_basic.rb

@@ -1,92 +1,68 @@
 require_relative "../parser_helper"
 
 class TestBasic < MiniTest::Test
-  # include the magic (setup and parse -> test method translation), see there
+  #test basics and keyword expressions. Keywords includes BasicTypes
   include ParserHelper
 
   def test_true
-    @string_input    = 'true '
-    @parse_output = {:true => 'true'}
-    @transform_output = Ast::TrueExpression.new()
-    @parser = @parser.basic_type
-  end
-  def test_false
-    @string_input    = 'false '
-    @parse_output = {:false => 'false'}
-    @transform_output = Ast::FalseExpression.new()
-    @parser = @parser.basic_type
-  end
-  def test_nil
-    @string_input    = 'nil '
-    @parse_output = {:nil => 'nil'}
-    @transform_output = Ast::NilExpression.new()
-    @parser = @parser.basic_type
+    @input    = 'true  '
+    @output = s(:true)
+    check :keyword_true
   end
 
-  def test_number
-    @string_input    = '42 '
-    @parse_output = {:integer => '42'}
-    @transform_output = Ast::IntegerExpression.new(42)
-    @parser = @parser.integer
+  def test_false
+    @input    = 'false '
+    @output = s(:false)
+    check :keyword_false
+  end
+
+  def test_nil
+    @input    = 'nil '
+    @output = s(:nil)
+    check :keyword_nil
+  end
+
+  def test_integer
+    @input    = '42 '
+    @output = s(:int , 42)
+    check :integer_expression
   end
 
   def test_name
-    @string_input    = 'foo '
-    @parse_output = {:name => 'foo'}
-    @transform_output = Ast::NameExpression.new('foo')
-    @parser = @parser.name
+    @input    = 'foo '
+    @output = 'foo'
+    check :name_expression
   end
 
   def test_name_underscode_start
-    @string_input    = '_bar '
-    @parse_output = {:name => '_bar'}
-    @transform_output = Ast::NameExpression.new('_bar')
-    @parser = @parser.name
+    @input    = '_bar '
+    @output = '_bar'
+    check :name_expression
   end
 
   def test_name_underscode_middle
-    @string_input    = 'foo_bar '
-    @parse_output = {:name => 'foo_bar'}
-    @transform_output = Ast::NameExpression.new('foo_bar')
-    @parser = @parser.name
-  end
-
-  def test_instance_variable
-    @string_input    = '@foo_bar '
-    @parse_output = {:instance_variable=>{:name=>"foo_bar"}}
-    @transform_output = Ast::VariableExpression.new(:foo_bar)
-    @parser = @parser.instance_variable
+    @input    = 'foo_bar '
+    @output = 'foo_bar'
+    check :name_expression
   end
 
   def test_module_name
-    @string_input    = 'FooBar '
-    @parse_output = {:module_name=>"FooBar"}
-    @transform_output = Ast::ModuleName.new("FooBar")
-    @parser = @parser.module_name
-  end
-
-  def test_comment
-    out = "# i am a comment \n"
-    @string_input    =  out.dup #NEEDS the return, which is what delimits the comment
-    @parse_output = out
-    @transform_output = @parse_output #dont transform
-    @parser = @parser.comment
+    @input    = 'FooBar '
+    @output = s(:aspect , "FooBar")
+    check :aspect_name_expression
   end
 
   def test_string
-    @string_input    = "\"hello\""
-    @parse_output =  {:string=>[{:char=>"h"}, {:char=>"e"}, {:char=>"l"}, {:char=>"l"}, {:char=>"o"}]}
-    @transform_output =  Ast::StringExpression.new('hello')
-    @parser = @parser.string
+    @input    = '"hello"'
+    @output =  s(:string , 'hello')
+    check :string_expression
   end
 
   def test_string_escapes
     out = 'hello  \nyou'
-    @string_input    = '"' + out + '"'
-    @parse_output =  {:string=>[{:char=>"h"}, {:char=>"e"}, {:char=>"l"}, {:char=>"l"}, {:char=>"o"}, 
-      {:char=>" "}, {:char=>" "}, {:esc=>"n"}, {:char=>"y"}, {:char=>"o"}, {:char=>"u"}]}
-    @transform_output =  Ast::StringExpression.new(out)
-    @parser = @parser.string
+    @input    = '"' + out + '"'
+    @output =  s(:string , out)
+    check :string_expression
   end
 
-end
+end

test/unit/test_block.rb

@@ -5,33 +5,33 @@ class TestBlock < MiniTest::Test
   include ParserHelper
 
   def pest_block
-    @string_input = <<HERE
+    @input = <<HERE
 while(1) do
   tmp = a
   puts(b)
 end
 HERE
-    @string_input.chop!
+    @input.chop!
     @parse_output = {:while=>"while", :while_cond=>{:integer=>"1"}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}], :end=>"end"}}
-    @transform_output = Ast::BlockExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self))] )
-    @parser = @parser.block
+    @output = Ast::BlockExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self))] )
+    @root = :block
   end
 
   def pest_block_method
-    @string_input = <<HERE
+    @input = <<HERE
 while(1) do
   tmp = String.new()
   tmp.puts(i)
 end
 HERE
-    @string_input.chop!
+    @input.chop!
     @parse_output = {:while=>"while", :while_cond=>{:integer=>"1"}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:receiver=>{:module_name=>"String"}, :call_site=>{:name=>"new"}, :argument_list=>[]}}, {:receiver=>{:name=>"tmp"}, :call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"i"}}]}], :end=>"end"}}
-    @transform_output = Ast::BlockExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::CallSiteExpression.new(:new, [] ,Ast::ModuleName.new(:String))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:i)] ,Ast::NameExpression.new(:tmp))] )
-    @parser = @parser.block
+    @output = Ast::BlockExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::CallSiteExpression.new(:new, [] ,Ast::ModuleName.new(:String))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:i)] ,Ast::NameExpression.new(:tmp))] )
+    @root = :block
   end
 
   def pest_big_block
-    @string_input = <<HERE
+    @input = <<HERE
 while( n > 1) do
   tmp = a
   a = b
@@ -40,9 +40,9 @@ while( n > 1) do
   n = n - 1
 end
 HERE
-    @string_input.chop!
+    @input.chop!
     @parse_output = {:while=>"while", :while_cond=>{:l=>{:name=>"n"}, :o=>"> ", :r=>{:integer=>"1"}}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:l=>{:name=>"a"}, :o=>"= ", :r=>{:name=>"b"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:l=>{:name=>"tmp"}, :o=>"+ ", :r=>{:name=>"b"}}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}, {:l=>{:name=>"n"}, :o=>"= ", :r=>{:l=>{:name=>"n"}, :o=>"- ", :r=>{:integer=>"1"}}}], :end=>"end"}}
-    @transform_output = Ast::BlockExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )
-    @parser = @parser.block
+    @output = Ast::BlockExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )
+    @root = :block
   end
 end

test/unit/test_call_site.rb

@@ -1,117 +1,43 @@
 require_relative "../parser_helper"
 
 class TestCallSite < MiniTest::Test
-  # include the magic (setup and parse -> test method translation), see there
   include ParserHelper
-    
-  def test_single_argument
-    @string_input = 'foo(42)'
-    @parse_output = {:call_site => {:name => 'foo'},
-             :argument_list    => [{:argument => {:integer => '42'} }] }
-    @transform_output = Ast::CallSiteExpression.new :foo, [Ast::IntegerExpression.new(42)]
-    @parser = @parser.call_site
-  end
 
   def test_single_self
-    @string_input = 'self.foo(42)'
-    @parse_output = {:receiver=>{:name=>"self"}, :call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"42"}}]}
-    @transform_output = Ast::CallSiteExpression.new :foo, [Ast::IntegerExpression.new(42)]
-    @parser = @parser.call_site
-  end
-
-  def test_single_instance
-    @string_input = '@var.foo(42)'
-    @parse_output = {:receiver=>{:instance_variable=>{:name=>"var"}}, :call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"42"}}]}
-    @transform_output = Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::VariableExpression.new(:var))
-    @parser = @parser.call_site
+    @input = 'self.foo(42)'
+    @output = s(:call, s(:field , "self" , "foo") , [s(:int, 42)])
+    check :call_site
   end
 
   def test_single_name
-    @string_input = 'my_my.foo(42)'
+    @input = 'my_my.foo(42)'
     @parse_output = {:receiver=>{:name=>"my_my"}, :call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"42"}}]}
-    @transform_output = Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::NameExpression.new("my_my"))
-    @parser = @parser.call_site
+    @output = s(:call, s(:field, "my_my", "foo"), [s(:int, 42)])
+    check :call_site
   end
 
   def test_int_receiver
-    @string_input = '42.put()'
-    @parse_output = {:receiver=>{:integer=>"42"}, :call_site=>{:name=>"put"}, :argument_list=>[]}
-    @transform_output = Ast::CallSiteExpression.new(:put, [] ,Ast::IntegerExpression.new(42))
-    @parser = @parser.call_site
+    @input = '42.put()'
+    @output = s(:call, s(:field, s(:int , 42) ,  "put") , [])
+    check :call_site
   end
 
   def test_string_receiver
-    @string_input = '"hello".puts()'
-    @parse_output = {:receiver=>{:string=>[{:char=>"h"}, {:char=>"e"}, {:char=>"l"}, {:char=>"l"}, {:char=>"o"}]}, :call_site=>{:name=>"puts"}, :argument_list=>[]}
-    @transform_output = Ast::CallSiteExpression.new(:puts, [] ,Ast::StringExpression.new("hello"))
-    @parser = @parser.call_site
+    @input = '"hello".puts()'
+    @output = s(:call , s(:field , s(:string , "hello") , "puts") , [])
+    check :call_site
   end
 
-  def test_single_class
-    @string_input = 'Object.foo(42)'
-    @parse_output = {:receiver=>{:module_name=>"Object"}, :call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"42"}}]}
-    @transform_output = Ast::CallSiteExpression.new(:foo, [Ast::IntegerExpression.new(42)] ,Ast::ModuleName.new("Object"))
-    @parser = @parser.call_site
+  def test_call_site_2
+    @input = 'self.baz(42, foo)'
+    @output = s(:call ,s(:field , "self", "baz") ,  [s(:int, 42), "foo"])
+    check :call_site
   end
 
-  def test_call_site_multi
-    @string_input = 'baz(42, foo)'
-    @parse_output = {:call_site => {:name => 'baz' },
-                     :argument_list    => [{:argument => {:integer => '42'}},
-                                           {:argument => {:name => 'foo'}}]}
-    @transform_output = Ast::CallSiteExpression.new :baz, 
-                           [Ast::IntegerExpression.new(42), Ast::NameExpression.new("foo") ]
-    @parser = @parser.call_site
+  def test_call_site_3
+    @input = 'self.baz(42, foo , bar)'
+    @output = s(:call,  s(:field, "self", "baz"), [s(:int, 42), "foo", "bar"])
+    check :call_site
   end
 
-  def test_call_site_string
-    @string_input    = 'puts( "hello")'
-    @parse_output = {:call_site => {:name => 'puts' },
-                      :argument_list    => [{:argument => 
-                        {:string=>[{:char=>"h"}, {:char=>"e"}, {:char=>"l"}, {:char=>"l"}, {:char=>"o"}]}}]}
-    @transform_output = Ast::CallSiteExpression.new "puts", [Ast::StringExpression.new("hello")]
-    @parser = @parser.call_site
-  end
-
-  def test_call_operator
-    @string_input    = 'puts( 3 + 5)'
-    @parse_output = {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+ ", :r=>{:integer=>"5"}}}]}
-    @transform_output = Ast::CallSiteExpression.new(:puts, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(5))] )
-    @parser = @parser.call_site
-  end
-
-  def test_call_two_operators
-    @string_input    = 'puts(3 + 5 , a - 3)'
-    @parse_output = {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+ ", :r=>{:integer=>"5"}}}, {:argument=>{:l=>{:name=>"a"}, :o=>"- ", :r=>{:integer=>"3"}}}]}
-    @transform_output = Ast::CallSiteExpression.new(:puts, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("-", Ast::NameExpression.new("a"),Ast::IntegerExpression.new(3))] )
-    @parser = @parser.call_site
-  end
-
-  def test_call_chaining
-    @string_input    = 'puts(putint(3 + 5 ), a - 3)'
-    @parse_output = {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:call_site=>{:name=>"putint"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+ ", :r=>{:integer=>"5"}}}]}}, {:argument=>{:l=>{:name=>"a"}, :o=>"- ", :r=>{:integer=>"3"}}}]}
-    @transform_output = Ast::CallSiteExpression.new(:puts, [Ast::CallSiteExpression.new(:putint, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(5))] ),Ast::OperatorExpression.new("-", Ast::NameExpression.new("a"),Ast::IntegerExpression.new(3))] )
-    @parser = @parser.call_site
-  end
-
-  def test_call_chaining_name
-    @string_input    = 'puts(name.putint(4), a)'
-    @parse_output = {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:receiver=>{:name=>"name"}, :call_site=>{:name=>"putint"}, :argument_list=>[{:argument=>{:integer=>"4"}}]}}, {:argument=>{:name=>"a"}}]}
-    @transform_output = Ast::CallSiteExpression.new(:puts, [Ast::CallSiteExpression.new(:putint, [Ast::IntegerExpression.new(4)] ,Ast::NameExpression.new("name")),Ast::NameExpression.new("a")] ,Ast::NameExpression.new("self"))
-    @parser = @parser.call_site
-  end
-
-  def test_call_chaining_class
-    @string_input    = 'Class.new(self.get(4))'
-    @parse_output = {:receiver=>{:module_name=>"Class"}, :call_site=>{:name=>"new"}, :argument_list=>[{:argument=>{:receiver=>{:name=>"self"}, :call_site=>{:name=>"get"}, :argument_list=>[{:argument=>{:integer=>"4"}}]}}]}
-    @transform_output = Ast::CallSiteExpression.new(:new, [Ast::CallSiteExpression.new(:get, [Ast::IntegerExpression.new(4)] ,Ast::NameExpression.new("self"))] ,Ast::ModuleName.new("Class"))
-    @parser = @parser.call_site
-  end
-  def test_call_chaining_instance
-    @string_input    = '@class.new(self.get(4))'
-    @parse_output = {:receiver=>{:instance_variable=>{:name=>"class"}}, :call_site=>{:name=>"new"}, :argument_list=>[{:argument=>{:receiver=>{:name=>"self"}, :call_site=>{:name=>"get"}, :argument_list=>[{:argument=>{:integer=>"4"}}]}}]}
-    @transform_output = Ast::CallSiteExpression.new(:new, [Ast::CallSiteExpression.new(:get, [Ast::IntegerExpression.new(4)] ,Ast::NameExpression.new("self"))] ,Ast::VariableExpression.new(:class))
-    @parser = @parser.call_site
-  end
-
-end
+end

test/unit/test_class.rb

@@ -5,18 +5,18 @@ class TestClassDef < MiniTest::Test
   include ParserHelper
   
   def test_simplest_class
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Foo
   5
 end
 HERE
     @parse_output = {:module_name=>"Foo", :derived_name=>nil, :class_expressions=>[{:integer=>"5"}], :end=>"end"}
-    @transform_output = Ast::ClassExpression.new(:Foo ,nil, [Ast::IntegerExpression.new(5)] )
-    @parser = @parser.class_definition
+    @output = Ast::ClassExpression.new(:Foo ,nil, [Ast::IntegerExpression.new(5)] )
+    @root = :class_definition
   end
 
   def test_class_ops
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Opers
   def foo(x)
     @abba = 5 
@@ -25,12 +25,12 @@ class Opers
 end
 HERE
     @parse_output = {:module_name=>"Opers", :derived_name=>nil, :class_expressions=>[{:function_name=>{:name=>"foo"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:l=>{:instance_variable=>{:name=>"abba"}}, :o=>"= ", :r=>{:integer=>"5"}}, {:l=>{:integer=>"2"}, :o=>"+ ", :r=>{:integer=>"5"}}], :end=>"end"}], :end=>"end"}
-    @transform_output = Ast::ClassExpression.new(:Opers ,nil, [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::VariableExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )] )
-    @parser = @parser.class_definition
+    @output = Ast::ClassExpression.new(:Opers ,nil, [Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::VariableExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )] )
+    @root = :class_definition
   end
 
   def test_class_if
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Ifi
   def ofthen(n)
     if(0)
@@ -42,12 +42,12 @@ class Ifi
 end
 HERE
     @parse_output = {:module_name=>"Ifi", :derived_name=>nil, :class_expressions=>[{:function_name=>{:name=>"ofthen"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:if=>"if", :conditional=>{:integer=>"0"}, :if_true=>{:expressions=>[{:l=>{:name=>"isit"}, :o=>"= ", :r=>{:integer=>"42"}}], :else=>"else"}, :if_false=>{:expressions=>[{:l=>{:name=>"maybenot"}, :o=>"= ", :r=>{:integer=>"667"}}], :end=>"end"}}], :end=>"end"}], :end=>"end"}
-    @transform_output = Ast::ClassExpression.new(:Ifi ,nil, [Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )] )
-    @parser = @parser.class_definition
+    @output = Ast::ClassExpression.new(:Ifi ,nil, [Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )] )
+    @root = :class_definition
   end
 
   def test_class_function
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Pifi
   ofthen(3+4 , var)
   def ofthen(n,m)
@@ -56,11 +56,11 @@ class Pifi
 end
 HERE
     @parse_output = {:module_name=>"Pifi", :derived_name=>nil, :class_expressions=>[{:call_site=>{:name=>"ofthen"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+", :r=>{:integer=>"4"}}}, {:argument=>{:name=>"var"}}]}, {:function_name=>{:name=>"ofthen"}, :parameter_list=>[{:parameter=>{:name=>"n"}}, {:parameter=>{:name=>"m"}}], :expressions=>[{:integer=>"44"}], :end=>"end"}], :end=>"end"}
-    @transform_output = Ast::ClassExpression.new(:Pifi ,nil, [Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self)), Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n),Ast::NameExpression.new(:m)] , [Ast::IntegerExpression.new(44)] ,nil )] )
-    @parser = @parser.class_definition
+    @output = Ast::ClassExpression.new(:Pifi ,nil, [Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self)), Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n),Ast::NameExpression.new(:m)] , [Ast::IntegerExpression.new(44)] ,nil )] )
+    @root = :class_definition
   end
   def test_class_module
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Foo
   module Boo
     funcall(3+4 , var)
@@ -68,21 +68,21 @@ class Foo
 end
 HERE
     @parse_output = {:module_name=>"Foo", :derived_name=>nil, :class_expressions=>[{:module_name=>"Boo", :module_expressions=>[{:call_site=>{:name=>"funcall"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+", :r=>{:integer=>"4"}}}, {:argument=>{:name=>"var"}}]}], :end=>"end"}], :end=>"end"}
-    @transform_output = Ast::ClassExpression.new(:Foo ,nil, [Ast::ModuleExpression.new(:Boo ,[Ast::CallSiteExpression.new(:funcall, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )] )
-    @parser = @parser.class_definition
+    @output = Ast::ClassExpression.new(:Foo ,nil, [Ast::ModuleExpression.new(:Boo ,[Ast::CallSiteExpression.new(:funcall, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )] )
+    @root = :class_definition
   end
   def test_class_derived
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Foo < Object
   ofthen(3+4 , var)
 end
 HERE
     @parse_output = {:module_name=>"Foo", :derived_name=>{:module_name=>"Object"}, :class_expressions=>[{:call_site=>{:name=>"ofthen"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+", :r=>{:integer=>"4"}}}, {:argument=>{:name=>"var"}}]}], :end=>"end"}
-    @transform_output = Ast::ClassExpression.new(:Foo ,:Object, [Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )
-    @parser = @parser.class_definition
+    @output = Ast::ClassExpression.new(:Foo ,:Object, [Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )
+    @root = :class_definition
   end
   def test_class_method
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Foo < Object
   def Foo.test()
     43
@@ -90,8 +90,8 @@ class Foo < Object
 end
 HERE
     @parse_output = {:module_name=>"Foo", :derived_name=>{:module_name=>"Object"}, :class_expressions=>[{:receiver=>{:module_name=>"Foo"}, :function_name=>{:name=>"test"}, :parameter_list=>[], :expressions=>[{:integer=>"43"}], :end=>"end"}], :end=>"end"}
-    @transform_output = Ast::ClassExpression.new(:Foo ,:Object, [Ast::FunctionExpression.new(:test, [] , [Ast::IntegerExpression.new(43)] ,Ast::ModuleName.new(:Foo) )] )
-    @parser = @parser.class_definition
+    @output = Ast::ClassExpression.new(:Foo ,:Object, [Ast::FunctionExpression.new(:test, [] , [Ast::IntegerExpression.new(43)] ,Ast::ModuleName.new(:Foo) )] )
+    @root = :class_definition
   end
   
 end

test/unit/test_compound.rb

@@ -5,47 +5,47 @@ class TestCompound < MiniTest::Test
   include ParserHelper
     
   def test_one_array
-    @string_input    = '[42]'
+    @input    = '[42]'
     @parse_output = {:array_constant=>[{:array_element=>{:integer=>"42"}}]}
-    @transform_output =  Ast::ArrayExpression.new([Ast::IntegerExpression.new(42)])
-    @parser = @parser.array_constant
+    @output =  Ast::ArrayExpression.new([Ast::IntegerExpression.new(42)])
+    @root = :array_constant
   end
 
   def test_array_list
-    @string_input    = '[42, foo]'
+    @input    = '[42, foo]'
     @parse_output = {:array_constant=>[{:array_element=>{:integer=>"42"}}, {:array_element=>{:name=>"foo"}}]}
-    @transform_output = Ast::ArrayExpression.new([Ast::IntegerExpression.new(42), Ast::NameExpression.new("foo")])
-    @parser = @parser.array_constant
+    @output = Ast::ArrayExpression.new([Ast::IntegerExpression.new(42), Ast::NameExpression.new("foo")])
+    @root = :array_constant
   end
 
   def test_array_list2
-    @string_input    = '[42, nil]'
+    @input    = '[42, nil]'
     @parse_output = {:array_constant=>[{:array_element=>{:integer=>"42"}}, {:array_element=>{:nil=>"nil"}}]}
-    @transform_output = Ast::ArrayExpression.new([Ast::IntegerExpression.new(42), Ast::NilExpression.new()])
-    @parser = @parser.array_constant
+    @output = Ast::ArrayExpression.new([Ast::IntegerExpression.new(42), Ast::NilExpression.new()])
+    @root = :array_constant
   end
 
   def test_array_ops
-    @string_input    = '[ 3 + 4 , foo(22) ]'
+    @input    = '[ 3 + 4 , foo(22) ]'
     @parse_output = {:array_constant=>[{:array_element=>{:l=>{:integer=>"3"}, :o=>"+ ", :r=>{:integer=>"4"}}}, {:array_element=>{:call_site=>{:name=>"foo"}, :argument_list=>[{:argument=>{:integer=>"22"}}]}}]}
-    @transform_output = Ast::ArrayExpression.new(
+    @output = Ast::ArrayExpression.new(
             [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)), 
               Ast::CallSiteExpression.new("foo", [Ast::IntegerExpression.new(22)] )])
-    @parser = @parser.array_constant
+    @root = :array_constant
   end
 
   def test_hash
-    @string_input = '{ foo => 33 }'
+    @input = '{ foo => 33 }'
     @parse_output = {:hash_constant=>[{:hash_pair=>{:hash_key=>{:name=>"foo"}, :hash_value=>{:integer=>"33"}}}]}
-    @transform_output = Ast::HashExpression.new([Ast::AssociationExpression.new(Ast::NameExpression.new("foo") , Ast::IntegerExpression.new(33))])
-    @parser = @parser.hash_constant
+    @output = Ast::HashExpression.new([Ast::AssociationExpression.new(Ast::NameExpression.new("foo") , Ast::IntegerExpression.new(33))])
+    @root = :hash_constant
   end
 
   def test_hash_list
-    @string_input = "{foo => 33 , bar => 42}"
+    @input = "{foo => 33 , bar => 42}"
     @parse_output = {:hash_constant=>[{:hash_pair=>{:hash_key=>{:name=>"foo"}, :hash_value=>{:integer=>"33"}}}, {:hash_pair=>{:hash_key=>{:name=>"bar"}, :hash_value=>{:integer=>"42"}}}]}
-    @transform_output = Ast::HashExpression.new([Ast::AssociationExpression.new(Ast::NameExpression.new("foo") , Ast::IntegerExpression.new(33)),Ast::AssociationExpression.new(Ast::NameExpression.new("bar") , Ast::IntegerExpression.new(42))])
-    @parser = @parser.hash_constant
+    @output = Ast::HashExpression.new([Ast::AssociationExpression.new(Ast::NameExpression.new("foo") , Ast::IntegerExpression.new(33)),Ast::AssociationExpression.new(Ast::NameExpression.new("bar") , Ast::IntegerExpression.new(42))])
+    @root = :hash_constant
   end
 
 end

test/unit/test_conditional.rb

@@ -1,74 +1,74 @@
 require_relative "../parser_helper"
 
 class TestConditional < MiniTest::Test
-  # include the magic (setup and parse -> test method translation), see there
   include ParserHelper
 
-  def test_conditional_brackets
-    check("(0)")
-  end
-  def test_conditional_no_brackets
-    check("0")
+  def test_assignment
+    @input = "myvar = 42"
+    @output = s(:assign, :myvar, s(:int, 42))
+    check :assignment
   end
 
-  def check cond
-    input = <<HERE
+  def test_variable_declaration
+    @input = "int myvar"
+    @output = s(:variable,s(:type, "int", "myvar"), nil)
+    check :variable_definition
+  end
 
-  42
-else
-  667
+  def test_variable_declaration_value
+    @input = "int myvar = 42"
+    @output = s(:variable,   s(:type, "int", "myvar"),   s(:int, 42))
+    check :variable_definition
+  end
+
+  def test_if
+    @input = <<HERE
+if( 1 )
+  int num = 42
 end
 HERE
-    @string_input = "if #{cond} " + input.chop!
-    @parse_output = {:if=>"if", :conditional=>{:integer=>"0"}, :if_true=>{:expressions=>[{:integer=>"42"}], :else=>"else"}, :if_false=>{:expressions=>[{:integer=>"667"}], :end=>"end"}}
-    @transform_output = Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::IntegerExpression.new(42)],[Ast::IntegerExpression.new(667)] )
-    @parser = @parser.conditional
+    @output = s(:if,   s(:cond,     s(:int, 1)),   s(:then, [s(:variable,
+                                              s(:type, "int", "num"),
+                                              s(:int, 42))]))
+    check :conditional
   end
 
   def test_conditional_with_calls
-    @string_input = <<HERE
-if(3 > var)
-  Object.initialize(3)
-else
-  var.new(33)
+    @input = <<HERE
+if(var)
+  42.add(5)
 end
 HERE
-    @string_input.chop!
-    @parse_output = {:if=>"if", :conditional=>{:l=>{:integer=>"3"}, :o=>"> ", :r=>{:name=>"var"}}, :if_true=>{:expressions=>[{:receiver=>{:module_name=>"Object"}, :call_site=>{:name=>"initialize"}, :argument_list=>[{:argument=>{:integer=>"3"}}]}], :else=>"else"}, :if_false=>{:expressions=>[{:receiver=>{:name=>"var"}, :call_site=>{:name=>"new"}, :argument_list=>[{:argument=>{:integer=>"33"}}]}], :end=>"end"}}
-    @transform_output = Ast::IfExpression.new(Ast::OperatorExpression.new(">", Ast::IntegerExpression.new(3),Ast::NameExpression.new("var")), [Ast::CallSiteExpression.new(:initialize, [Ast::IntegerExpression.new(3)] ,Ast::ModuleName.new("Object"))],[Ast::CallSiteExpression.new(:new, [Ast::IntegerExpression.new(33)] ,Ast::NameExpression.new("var"))] )
-    @parser = @parser.conditional
+    @output = s(:if,
+                s(:cond, "var"),
+                s(:then, [s(:call, s(:field, s(:int, 42), "add"), [s(:int, 5)])]))
+    check :conditional
   end
 
-  def test_conditional_nil
-    @string_input = <<HERE
+  def ttest_conditional_nil
+    @input = <<HERE
 if(3 == nil)
   3
 else
 4
 end
 HERE
-    @string_input.chop!
+    @input.chop!
     @parse_output = {:if=>"if", :conditional=>{:l=>{:integer=>"3"}, :o=>"== ", :r=>{:nil=>"nil"}}, :if_true=>{:expressions=>[{:integer=>"3"}], :else=>"else"}, :if_false=>{:expressions=>[{:integer=>"4"}], :end=>"end"}}
-    @transform_output = Ast::IfExpression.new(Ast::OperatorExpression.new("==", Ast::IntegerExpression.new(3),Ast::NilExpression.new()), [Ast::IntegerExpression.new(3)],[Ast::IntegerExpression.new(4)] )
-    @parser = @parser.conditional
+    @output = nil
+    @root = :conditional
   end
 
   def pest_simple_if
-    @string_input = <<HERE
+    @input = <<HERE
 if(3 == nil)
   3
 end
 HERE
-    @string_input.chop!
+    @input.chop!
     @parse_output = {:if=>"if", :conditional=>{:l=>{:integer=>"3"}, :o=>"== ", :r=>{:nil=>"nil"}}, :if_true=>{:expressions=>[{:integer=>"3"}], :else=>"else"}, :if_false=>{:expressions=>[{:integer=>"4"}], :end=>"end"}}
-    @transform_output = Ast::IfExpression.new(Ast::OperatorExpression.new("==", Ast::IntegerExpression.new(3),Ast::NilExpression.new()), [Ast::IntegerExpression.new(3)],[Ast::IntegerExpression.new(4)] )
-    @parser = @parser.conditional
+    @output = nil
+    @root = :conditional
   end
 
-  def pest_reverse_if
-    @string_input = "3  if(3 == nil)"
-    @parse_output = {:if=>"if", :conditional=>{:l=>{:integer=>"3"}, :o=>"== ", :r=>{:nil=>"nil"}}, :if_true=>{:expressions=>[{:integer=>"3"}], :else=>"else"}, :if_false=>{:expressions=>[{:integer=>"4"}], :end=>"end"}}
-    @transform_output = Ast::IfExpression.new(Ast::OperatorExpression.new("==", Ast::IntegerExpression.new(3),Ast::NilExpression.new()), [Ast::IntegerExpression.new(3)],[Ast::IntegerExpression.new(4)] )
-    @parser = @parser.conditional
-  end
 end

test/unit/test_expressions.rb

@@ -5,35 +5,35 @@ class TestExpressions < MiniTest::Test
   include ParserHelper
     
   def test_expression_else
-    @string_input    = <<HERE
+    @input    = <<HERE
 dud
 fuu(3)
 else
 HERE
-    @string_input.chop!
+    @input.chop!
     @parse_output = {:expressions=>[{:name=>"dud"}, 
       {:call_site=>{:name=>"fuu"}, :argument_list=>[{:argument=>{:integer=>"3"}}]}], 
       :else=>"else"}
-    @transform_output ={:expressions=>[Ast::NameExpression.new("dud"), 
+    @output ={:expressions=>[Ast::NameExpression.new("dud"), 
           Ast::CallSiteExpression.new("fuu", [Ast::IntegerExpression.new(3)] )], :else=>"else"}
-    @parser = @parser.expressions_else
+    @root = :expressions_else
   end
 
   def test_expression_end
-    @string_input    = <<HERE
+    @input    = <<HERE
 name
 call(4,6)
 end
 HERE
-    @string_input.chop!
+    @input.chop!
     @parse_output = {:expressions=>[{:name=>"name"}, 
       {:call_site=>{:name=>"call"}, :argument_list=>[{:argument=>{:integer=>"4"}}, {:argument=>{:integer=>"6"}}]}], 
       :end=>"end"}
-    @transform_output = {:expressions=>[Ast::NameExpression.new("name"), 
+    @output = {:expressions=>[Ast::NameExpression.new("name"), 
       Ast::CallSiteExpression.new("call", [Ast::IntegerExpression.new(4),Ast::IntegerExpression.new(6)] )], 
       :end=>"end"}
 
-    @parser = @parser.expressions_end
+    @root = :expressions_end
   end
 
 

test/unit/test_fails.rb

@@ -12,7 +12,7 @@ class TestFails < MiniTest::Test
   include ParserHelper
   
   def test_fail_function
-    @string_input    = <<HERE
+    @input    = <<HERE
 class Foo
   def bar
     4
@@ -20,7 +20,7 @@ class Foo
 end
 HERE
     @parse_output = nil
-    @transform_output = nil
-    @parser = @parser.root
+    @output = nil
+    @root = :root
   end
 end

test/unit/test_function_definition.rb

@@ -5,41 +5,41 @@ class TestFunctionDefinition < MiniTest::Test
   include ParserHelper
   
   def test_simplest_function
-    @string_input    = <<HERE
+    @input    = <<HERE
 def foo(x) 
   5
 end
 HERE
     @parse_output = {:function_name=>{:name=>"foo"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:integer=>"5"}], :end=>"end"}
-    @transform_output = Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new("x")] , [Ast::IntegerExpression.new(5)] )
-    @parser = @parser.function_definition
+    @output = Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new("x")] , [Ast::IntegerExpression.new(5)] )
+    @root = :function_definition
   end
 
   def test_class_function
-    @string_input    = <<HERE
+    @input    = <<HERE
 def String.length(x)
   @length
 end
 HERE
     @parse_output = {:receiver=>{:module_name=>"String"}, :function_name=>{:name=>"length"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:instance_variable=>{:name=>"length"}}], :end=>"end"}
-    @transform_output = Ast::FunctionExpression.new(:length, [Ast::NameExpression.new("x")] , [Ast::VariableExpression.new(:length)] ,Ast::ModuleName.new("String") )
-    @parser = @parser.function_definition
+    @output = Ast::FunctionExpression.new(:length, [Ast::NameExpression.new("x")] , [Ast::VariableExpression.new(:length)] ,Ast::ModuleName.new("String") )
+    @root = :function_definition
   end
 
   def test_function_ops
-    @string_input    = <<HERE
+    @input    = <<HERE
 def foo(x) 
  abba = 5 
  2 + 5
 end
 HERE
     @parse_output = {:function_name=>{:name=>"foo"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:l=>{:name=>"abba"}, :o=>"= ", :r=>{:integer=>"5"}}, {:l=>{:integer=>"2"}, :o=>"+ ", :r=>{:integer=>"5"}}], :end=>"end"}
-    @transform_output = Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )
-    @parser = @parser.function_definition
+    @output = Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )
+    @root = :function_definition
   end
 
   def test_function_if
-    @string_input    = <<HERE
+    @input    = <<HERE
 def ofthen(n)
   if(0)
     isit = 42
@@ -49,24 +49,24 @@ def ofthen(n)
 end
 HERE
     @parse_output = {:function_name=>{:name=>"ofthen"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:if=>"if", :conditional=>{:integer=>"0"}, :if_true=>{:expressions=>[{:l=>{:name=>"isit"}, :o=>"= ", :r=>{:integer=>"42"}}], :else=>"else"}, :if_false=>{:expressions=>[{:l=>{:name=>"maybenot"}, :o=>"= ", :r=>{:integer=>"667"}}], :end=>"end"}}], :end=>"end"}
-    @transform_output = Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )
-    @parser = @parser.function_definition
+    @output = Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )
+    @root = :function_definition
   end
 
   def test_function_return
-    @string_input    = <<HERE
+    @input    = <<HERE
 def retvar(n)
   i = 5
   return i 
 end
 HERE
     @parse_output = {:function_name=>{:name=>"retvar"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:l=>{:name=>"i"}, :o=>"= ", :r=>{:integer=>"5"}}, {:return=>"return", :return_expression=>{:name=>"i"}}], :end=>"end"}
-    @transform_output = Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:i),Ast::IntegerExpression.new(5)),Ast::ReturnExpression.new(Ast::NameExpression.new(:i) )] ,nil )
-    @parser = @parser.function_definition
+    @output = Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:i),Ast::IntegerExpression.new(5)),Ast::ReturnExpression.new(Ast::NameExpression.new(:i) )] ,nil )
+    @root = :function_definition
   end
 
   def test_function_return_if
-    @string_input    = <<HERE
+    @input    = <<HERE
 def retvar(n)
   if( n > 5)
     return 10
@@ -76,12 +76,12 @@ def retvar(n)
 end
 HERE
     @parse_output = {:function_name=>{:name=>"retvar"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:if=>"if", :conditional=>{:l=>{:name=>"n"}, :o=>"> ", :r=>{:integer=>"5"}}, :if_true=>{:expressions=>[{:return=>"return", :return_expression=>{:integer=>"10"}}], :else=>"else"}, :if_false=>{:expressions=>[{:return=>"return", :return_expression=>{:integer=>"20"}}], :end=>"end"}}], :end=>"end"}
-    @transform_output = Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new("n")] , [Ast::IfExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new("n"),Ast::IntegerExpression.new(5)), [Ast::ReturnExpression.new(Ast::IntegerExpression.new(10) )],[Ast::ReturnExpression.new(Ast::IntegerExpression.new(20) )] )] )
-    @parser = @parser.function_definition
+    @output = Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new("n")] , [Ast::IfExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new("n"),Ast::IntegerExpression.new(5)), [Ast::ReturnExpression.new(Ast::IntegerExpression.new(10) )],[Ast::ReturnExpression.new(Ast::IntegerExpression.new(20) )] )] )
+    @root = :function_definition
   end
 
   def test_function_return_while
-    @string_input    = <<HERE
+    @input    = <<HERE
 def retvar(n)
   while( n > 5) do
     n = n + 1
@@ -90,12 +90,12 @@ def retvar(n)
 end
 HERE
     @parse_output = {:function_name=>{:name=>"retvar"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:while=>"while", :while_cond=>{:l=>{:name=>"n"}, :o=>"> ", :r=>{:integer=>"5"}}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"n"}, :o=>"= ", :r=>{:l=>{:name=>"n"}, :o=>"+ ", :r=>{:integer=>"1"}}}, {:return=>"return", :return_expression=>{:name=>"n"}}], :end=>"end"}}], :end=>"end"}
-    @transform_output = Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new(:n)] , [Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(5)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1))), Ast::ReturnExpression.new(Ast::NameExpression.new(:n) )] )] ,nil )
-    @parser = @parser.function_definition
+    @output = Ast::FunctionExpression.new(:retvar, [Ast::NameExpression.new(:n)] , [Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(5)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1))), Ast::ReturnExpression.new(Ast::NameExpression.new(:n) )] )] ,nil )
+    @root = :function_definition
   end
 
   def test_function_while
-    @string_input    = <<HERE
+    @input    = <<HERE
 def fibonaccit(n)
   a = 0
   while (n) do
@@ -105,12 +105,12 @@ def fibonaccit(n)
 end
 HERE
     @parse_output = {:function_name=>{:name=>"fibonaccit"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:l=>{:name=>"a"}, :o=>"= ", :r=>{:integer=>"0"}}, {:while=>"while", :while_cond=>{:name=>"n"}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"some"}, :o=>"= ", :r=>{:integer=>"43"}}, {:l=>{:name=>"other"}, :o=>"= ", :r=>{:l=>{:name=>"some"}, :o=>"* ", :r=>{:integer=>"4"}}}], :end=>"end"}}], :end=>"end"}
-    @transform_output = Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::WhileExpression.new(Ast::NameExpression.new(:n), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:some),Ast::IntegerExpression.new(43)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:other),Ast::OperatorExpression.new("*", Ast::NameExpression.new(:some),Ast::IntegerExpression.new(4)))] )] ,nil )
-    @parser = @parser.function_definition
+    @output = Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::WhileExpression.new(Ast::NameExpression.new(:n), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:some),Ast::IntegerExpression.new(43)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:other),Ast::OperatorExpression.new("*", Ast::NameExpression.new(:some),Ast::IntegerExpression.new(4)))] )] ,nil )
+    @root = :function_definition
   end
 
   def test_function_big_while
-    @string_input    = <<HERE
+    @input    = <<HERE
 def fibonaccit(n)
   a = 0 
   b = 1
@@ -124,7 +124,7 @@ def fibonaccit(n)
 end
 HERE
     @parse_output = {:function_name=>{:name=>"fibonaccit"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:l=>{:name=>"a"}, :o=>"= ", :r=>{:integer=>"0"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:integer=>"1"}}, {:while=>"while", :while_cond=>{:l=>{:name=>"n"}, :o=>"> ", :r=>{:integer=>"1"}}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:l=>{:name=>"a"}, :o=>"= ", :r=>{:name=>"b"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:l=>{:name=>"tmp"}, :o=>"+ ", :r=>{:name=>"b"}}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}, {:l=>{:name=>"n"}, :o=>"= ", :r=>{:l=>{:name=>"n"}, :o=>"- ", :r=>{:integer=>"1"}}}], :end=>"end"}}], :end=>"end"}
-    @transform_output = Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::IntegerExpression.new(1)),Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )] ,nil )
-    @parser = @parser.function_definition
+    @output = Ast::FunctionExpression.new(:fibonaccit, [Ast::NameExpression.new(:n)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(0)),Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::IntegerExpression.new(1)),Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )] ,nil )
+    @root = :function_definition
   end  
 end

test/unit/test_module.rb

@@ -5,18 +5,18 @@ class TestModuleDef < MiniTest::Test
   include ParserHelper
   
   def test_simplest_module
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Simple
   5
 end
 HERE
     @parse_output = {:module_name=>"Simple", :module_expressions=>[{:integer=>"5"}], :end=>"end"}
-    @transform_output = Ast::ModuleExpression.new(:Simple ,[Ast::IntegerExpression.new(5)] )
-    @parser = @parser.module_definition
+    @output = Ast::ModuleExpression.new(:Simple ,[Ast::IntegerExpression.new(5)] )
+    @root = :module_definition
   end
 
   def test_module_ops
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Opers
   def foo(x)
     abba = 5
@@ -25,23 +25,23 @@ module Opers
 end
 HERE
     @parse_output = {:module_name=>"Opers", :module_expressions=>[{:function_name=>{:name=>"foo"}, :parameter_list=>[{:parameter=>{:name=>"x"}}], :expressions=>[{:l=>{:name=>"abba"}, :o=>"= ", :r=>{:integer=>"5"}}, {:l=>{:integer=>"2"}, :o=>"+ ", :r=>{:integer=>"5"}}], :end=>"end"}], :end=>"end"}
-    @transform_output = Ast::ModuleExpression.new(:Opers ,[Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )] )
-    @parser = @parser.module_definition
+    @output = Ast::ModuleExpression.new(:Opers ,[Ast::FunctionExpression.new(:foo, [Ast::NameExpression.new(:x)] , [Ast::AssignmentExpression.new(Ast::NameExpression.new(:abba),Ast::IntegerExpression.new(5)),Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(5))] ,nil )] )
+    @root = :module_definition
   end
 
   def test_module_assign_instance
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Opers
   @abba = 5
 end
 HERE
     @parse_output = {:module_name=>"Opers", :module_expressions=>[{:l=>{:instance_variable=>{:name=>"abba"}}, :o=>"= ", :r=>{:integer=>"5"}}], :end=>"end"}
-    @transform_output = Ast::ModuleExpression.new(:Opers ,[Ast::AssignmentExpression.new(Ast::VariableExpression.new(:abba),Ast::IntegerExpression.new(5))] )
-    @parser = @parser.module_definition
+    @output = Ast::ModuleExpression.new(:Opers ,[Ast::AssignmentExpression.new(Ast::VariableExpression.new(:abba),Ast::IntegerExpression.new(5))] )
+    @root = :module_definition
   end
 
   def test_module_if
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Foo
   def ofthen(n)
     if(0)
@@ -53,12 +53,12 @@ module Foo
 end
 HERE
     @parse_output = {:module_name=>"Foo", :module_expressions=>[{:function_name=>{:name=>"ofthen"}, :parameter_list=>[{:parameter=>{:name=>"n"}}], :expressions=>[{:if=>"if", :conditional=>{:integer=>"0"}, :if_true=>{:expressions=>[{:l=>{:name=>"isit"}, :o=>"= ", :r=>{:integer=>"42"}}], :else=>"else"}, :if_false=>{:expressions=>[{:l=>{:name=>"maybenot"}, :o=>"= ", :r=>{:integer=>"667"}}], :end=>"end"}}], :end=>"end"}], :end=>"end"}
-    @transform_output = Ast::ModuleExpression.new(:Foo ,[Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )] )
-    @parser = @parser.module_definition
+    @output = Ast::ModuleExpression.new(:Foo ,[Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new(:n)] , [Ast::IfExpression.new(Ast::IntegerExpression.new(0), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:isit),Ast::IntegerExpression.new(42))],[Ast::AssignmentExpression.new(Ast::NameExpression.new(:maybenot),Ast::IntegerExpression.new(667))] )] ,nil )] )
+    @root = :module_definition
   end
 
   def test_module_function
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Soho
   ofthen(3+4 , var)
   def ofthen(n,m)
@@ -67,12 +67,12 @@ module Soho
 end
 HERE
     @parse_output = {:module_name=>"Soho", :module_expressions=>[{:call_site=>{:name=>"ofthen"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+", :r=>{:integer=>"4"}}}, {:argument=>{:name=>"var"}}]}, {:function_name=>{:name=>"ofthen"}, :parameter_list=>[{:parameter=>{:name=>"n"}}, {:parameter=>{:name=>"m"}}], :expressions=>[{:integer=>"44"}], :end=>"end"}], :end=>"end"}
-    @transform_output = Ast::ModuleExpression.new(:Soho ,[Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new("var")] ), Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new("n"),Ast::NameExpression.new("m")] , [Ast::IntegerExpression.new(44)] )] )
-    @parser = @parser.module_definition
+    @output = Ast::ModuleExpression.new(:Soho ,[Ast::CallSiteExpression.new(:ofthen, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new("var")] ), Ast::FunctionExpression.new(:ofthen, [Ast::NameExpression.new("n"),Ast::NameExpression.new("m")] , [Ast::IntegerExpression.new(44)] )] )
+    @root = :module_definition
   end
 
   def test_module_class
-    @string_input    = <<HERE
+    @input    = <<HERE
 module Foo
   class Bar
     funcall(3+4 , var)
@@ -80,7 +80,7 @@ module Foo
 end
 HERE
     @parse_output = {:module_name=>"Foo", :module_expressions=>[{:module_name=>"Bar", :derived_name=>nil, :class_expressions=>[{:call_site=>{:name=>"funcall"}, :argument_list=>[{:argument=>{:l=>{:integer=>"3"}, :o=>"+", :r=>{:integer=>"4"}}}, {:argument=>{:name=>"var"}}]}], :end=>"end"}], :end=>"end"}
-    @transform_output = Ast::ModuleExpression.new(:Foo ,[Ast::ClassExpression.new(:Bar ,nil, [Ast::CallSiteExpression.new(:funcall, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )] )
-    @parser = @parser.module_definition
+    @output = Ast::ModuleExpression.new(:Foo ,[Ast::ClassExpression.new(:Bar ,nil, [Ast::CallSiteExpression.new(:funcall, [Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)),Ast::NameExpression.new(:var)] ,Ast::NameExpression.new(:self))] )] )
+    @root = :module_definition
   end
 end

test/unit/test_operators.rb

@@ -5,10 +5,10 @@ class TestExpressions < MiniTest::Test
   include ParserHelper
 
   def simple_op op
-    @string_input    = "5 #{op} 3"
+    @input    = "5 #{op} 3"
     @parse_output = {:l=>{:integer=>"5"}, :o=>"#{op} ", :r=>{:integer=>"3"}}
-    @transform_output = Ast::OperatorExpression.new(op, Ast::IntegerExpression.new(5),Ast::IntegerExpression.new(3))
-    @parser = @parser.operator_expression
+    @output = Ast::OperatorExpression.new(op, Ast::IntegerExpression.new(5),Ast::IntegerExpression.new(3))
+    @root = :operator_expression
   end
   def test_simple_multiply
     simple_op "*"
@@ -29,58 +29,58 @@ class TestExpressions < MiniTest::Test
     simple_op "<"
   end
   def test_op_variable
-    @string_input    = "a + 35"
+    @input    = "a + 35"
     @parse_output = {:l=>{:name=>"a"}, :o=>"+ ", :r=>{:integer=>"35"}}
-    @transform_output = Ast::OperatorExpression.new("+", Ast::NameExpression.new(:a),Ast::IntegerExpression.new(35))
-    @parser = @parser.operator_expression
+    @output = Ast::OperatorExpression.new("+", Ast::NameExpression.new(:a),Ast::IntegerExpression.new(35))
+    @root = :operator_expression
   end
   def test_op_two_variable
-    @string_input    = "a - b"
+    @input    = "a - b"
     @parse_output = {:l=>{:name=>"a"}, :o=>"- ", :r=>{:name=>"b"}}
-    @transform_output = Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::NameExpression.new("b"))
-    @parser = @parser.operator_expression
+    @output = Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::NameExpression.new("b"))
+    @root = :operator_expression
   end
   def test_op_instance_variable
-    @string_input    = "@a - 5"
+    @input    = "@a - 5"
     @parse_output = {:l=>{:instance_variable=>{:name=>"a"}}, :o=>"- ", :r=>{:integer=>"5"}}
-    @transform_output = Ast::OperatorExpression.new("-", Ast::VariableExpression.new(:a),Ast::IntegerExpression.new(5))
-    @parser = @parser.operator_expression
+    @output = Ast::OperatorExpression.new("-", Ast::VariableExpression.new(:a),Ast::IntegerExpression.new(5))
+    @root = :operator_expression
   end
   def test_op_variable_string
-    @string_input    = 'a - "st"'
+    @input    = 'a - "st"'
     @parse_output = {:l=>{:name=>"a"}, :o=>"- ", :r=>{:string=>[{:char=>"s"}, {:char=>"t"}]}}
-    @transform_output = Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::StringExpression.new("st"))
-    @parser = @parser.operator_expression
+    @output = Ast::OperatorExpression.new("-", Ast::NameExpression.new(:a),Ast::StringExpression.new("st"))
+    @root = :operator_expression
   end
   def test_two_same_ops
-    @string_input    = '2 + 3 + 4'
+    @input    = '2 + 3 + 4'
     @parse_output = {:l=>{:l=>{:integer=>"2"}, :o=>"+ ", :r=>{:integer=>"3"}}, :o=>"+ ", :r=>{:integer=>"4"}}
-    @transform_output = Ast::OperatorExpression.new("+", Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(3)),Ast::IntegerExpression.new(4))
-    @parser = @parser.operator_expression
+    @output = Ast::OperatorExpression.new("+", Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(3)),Ast::IntegerExpression.new(4))
+    @root = :operator_expression
   end
   def test_two_different_ops
-    @string_input    = '2 + 3 * 4'
+    @input    = '2 + 3 * 4'
     @parse_output = {:l=>{:integer=>"2"}, :o=>"+ ", :r=>{:l=>{:integer=>"3"}, :o=>"* ", :r=>{:integer=>"4"}}}
-    @transform_output = Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::OperatorExpression.new("*", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)))
-    @parser = @parser.operator_expression
+    @output = Ast::OperatorExpression.new("+", Ast::IntegerExpression.new(2),Ast::OperatorExpression.new("*", Ast::IntegerExpression.new(3),Ast::IntegerExpression.new(4)))
+    @root = :operator_expression
   end
   def test_two_different_ops_order
-    @string_input    = '2 * 3 + 4'
+    @input    = '2 * 3 + 4'
     @parse_output = {:l=>{:l=>{:integer=>"2"}, :o=>"* ", :r=>{:integer=>"3"}}, :o=>"+ ", :r=>{:integer=>"4"}}
-    @transform_output = Ast::OperatorExpression.new("+", Ast::OperatorExpression.new("*", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(3)),Ast::IntegerExpression.new(4))
-    @parser = @parser.operator_expression
+    @output = Ast::OperatorExpression.new("+", Ast::OperatorExpression.new("*", Ast::IntegerExpression.new(2),Ast::IntegerExpression.new(3)),Ast::IntegerExpression.new(4))
+    @root = :operator_expression
   end
   def test_assignment
-    @string_input    = "a = 5"
+    @input    = "a = 5"
     @parse_output = {:l=>{:name=>"a"}, :o=>"= ", :r=>{:integer=>"5"}}
-    @transform_output = Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(5))
-    @parser = @parser.operator_expression
+    @output = Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::IntegerExpression.new(5))
+    @root = :operator_expression
   end
   def test_assignment_instance
-    @string_input    = "@a = 5"
+    @input    = "@a = 5"
     @parse_output = {:l=>{:instance_variable=>{:name=>"a"}}, :o=>"= ", :r=>{:integer=>"5"}}
-    @transform_output = Ast::AssignmentExpression.new(Ast::VariableExpression.new(:a),Ast::IntegerExpression.new(5))
-    @parser = @parser.operator_expression
+    @output = Ast::AssignmentExpression.new(Ast::VariableExpression.new(:a),Ast::IntegerExpression.new(5))
+    @root = :operator_expression
   end
 
 end

test/unit/test_return.rb

@@ -5,31 +5,31 @@ class TestReturn < MiniTest::Test
   include ParserHelper
     
   def test_return_int
-    @string_input = 'return 42'
+    @input = 'return 42'
     @parse_output = {:return=>"return", :return_expression=>{:integer=>"42"}}
-    @transform_output = Ast::ReturnExpression.new(Ast::IntegerExpression.new(42) )
-    @parser = @parser.simple_return
+    @output = Ast::ReturnExpression.new(Ast::IntegerExpression.new(42) )
+    @root = :simple_return
   end
 
   def test_return_variable
-    @string_input = 'return foo'
+    @input = 'return foo'
     @parse_output = {:return=>"return", :return_expression=>{:name=>"foo"}}
-    @transform_output = Ast::ReturnExpression.new(Ast::NameExpression.new("foo") )
-    @parser = @parser.simple_return
+    @output = Ast::ReturnExpression.new(Ast::NameExpression.new("foo") )
+    @root = :simple_return
   end
 
   def test_return_string
-    @string_input    = 'return "hello"'
+    @input    = 'return "hello"'
     @parse_output = {:return=>"return", :return_expression=>{:string=>[{:char=>"h"}, {:char=>"e"}, {:char=>"l"}, {:char=>"l"}, {:char=>"o"}]}}
-    @transform_output = Ast::ReturnExpression.new(Ast::StringExpression.new("hello") )
-    @parser = @parser.simple_return
+    @output = Ast::ReturnExpression.new(Ast::StringExpression.new("hello") )
+    @root = :simple_return
   end
 
   def test_return_true
-    @string_input    = 'return true'
+    @input    = 'return true'
     @parse_output = {:return=>"return", :return_expression=>{:true=>"true"}}
-    @transform_output = Ast::ReturnExpression.new(Ast::TrueExpression.new() )
-    @parser = @parser.simple_return
+    @output = Ast::ReturnExpression.new(Ast::TrueExpression.new() )
+    @root = :simple_return
   end
 
 end

test/unit/test_while.rb

@@ -5,40 +5,40 @@ class TestWhile < MiniTest::Test
   include ParserHelper
 
   def test_while
-    @string_input = <<HERE
+    @input = <<HERE
 while(1) do
   tmp = a
   puts(b)
 end
 HERE
-    @string_input.chop!
+    @input.chop!
     @parse_output = {:while=>"while", :while_cond=>{:integer=>"1"}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}], :end=>"end"}}
-    @transform_output = Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self))] )
-    @parser = @parser.while_do
+    @output = Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self))] )
+    @root = :while_do
   end
 
   def pest_while_reverse
-    @string_input =  "puts '1' while true "
+    @input =  "puts '1' while true "
     @parse_output = {:while=>"while", :while_cond=>{:integer=>"1"}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}], :end=>"end"}}
-    @transform_output = Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self))] )
-    @parser = @parser.while_do
+    @output = Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self))] )
+    @root = :while_do
   end
 
   def test_while_method
-    @string_input = <<HERE
+    @input = <<HERE
 while(1) do
   tmp = String.new()
   tmp.puts(i)
 end
 HERE
-    @string_input.chop!
+    @input.chop!
     @parse_output = {:while=>"while", :while_cond=>{:integer=>"1"}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:receiver=>{:module_name=>"String"}, :call_site=>{:name=>"new"}, :argument_list=>[]}}, {:receiver=>{:name=>"tmp"}, :call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"i"}}]}], :end=>"end"}}
-    @transform_output = Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::CallSiteExpression.new(:new, [] ,Ast::ModuleName.new(:String))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:i)] ,Ast::NameExpression.new(:tmp))] )
-    @parser = @parser.while_do
+    @output = Ast::WhileExpression.new(Ast::IntegerExpression.new(1), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::CallSiteExpression.new(:new, [] ,Ast::ModuleName.new(:String))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:i)] ,Ast::NameExpression.new(:tmp))] )
+    @root = :while_do
   end
 
   def test_big_while
-    @string_input = <<HERE
+    @input = <<HERE
 while( n > 1) do
   tmp = a
   a = b
@@ -47,9 +47,9 @@ while( n > 1) do
   n = n - 1
 end
 HERE
-    @string_input.chop!
+    @input.chop!
     @parse_output = {:while=>"while", :while_cond=>{:l=>{:name=>"n"}, :o=>"> ", :r=>{:integer=>"1"}}, :do=>"do", :body=>{:expressions=>[{:l=>{:name=>"tmp"}, :o=>"= ", :r=>{:name=>"a"}}, {:l=>{:name=>"a"}, :o=>"= ", :r=>{:name=>"b"}}, {:l=>{:name=>"b"}, :o=>"= ", :r=>{:l=>{:name=>"tmp"}, :o=>"+ ", :r=>{:name=>"b"}}}, {:call_site=>{:name=>"puts"}, :argument_list=>[{:argument=>{:name=>"b"}}]}, {:l=>{:name=>"n"}, :o=>"= ", :r=>{:l=>{:name=>"n"}, :o=>"- ", :r=>{:integer=>"1"}}}], :end=>"end"}}
-    @transform_output = Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )
-    @parser = @parser.while_do
+    @output = Ast::WhileExpression.new(Ast::OperatorExpression.new(">", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)), [Ast::AssignmentExpression.new(Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:a)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:a),Ast::NameExpression.new(:b)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:b),Ast::OperatorExpression.new("+", Ast::NameExpression.new(:tmp),Ast::NameExpression.new(:b))), Ast::CallSiteExpression.new(:puts, [Ast::NameExpression.new(:b)] ,Ast::NameExpression.new(:self)), Ast::AssignmentExpression.new(Ast::NameExpression.new(:n),Ast::OperatorExpression.new("-", Ast::NameExpression.new(:n),Ast::IntegerExpression.new(1)))] )
+    @root = :while_do
   end
 end