ParseTree 1.5.0 → 1.6.0

data/test/something.rb

@@ -5,131 +5,6 @@ class Something
     1 + 1
   end
 
-  # basically: do we work at all?
-  def empty
-  end
-
-  # First order transformation: basic language constructs
-  def stupid
-    return nil
-  end
-
-  def simple(arg1)
-    print arg1
-    puts((4 + 2).to_s)
-  end
-
-  def global
-    $stderr.fputs("blah")
-  end
-
-  def lasgn_call
-    c = 2 + 3
-  end
-
-  def conditional1(arg1)
-    if arg1 == 0 then
-      return 1
-    end
-  end
-
-  def conditional2(arg1)
-    unless arg1 == 0 then
-      return 2
-    end
-  end
-
-  def conditional3(arg1)
-    if arg1 == 0 then
-      return 3
-    else
-      return 4
-    end
-  end
-
-  def conditional4(arg1)
-    if arg1 == 0 then
-      return 2
-    elsif arg1 < 0 then
-      return 3
-    else
-      return 4
-    end
-  end
-
-  def iteration1
-    array = [1, 2, 3]
-    array.each do |x|
-      y = x.to_s
-      puts(y)
-    end
-  end
-
-  def iteration2
-    array = [1, 2, 3]
-    array.each { |x|
-      y = x.to_s
-      puts(y)
-    }
-  end
-
-  def iteration3
-    array1 = [1, 2, 3]
-    array2 = [4, 5, 6, 7]
-    array1.each do |x|
-      array2.each do |y|
-	puts(x.to_s)
-	puts(y.to_s)
-      end
-    end
-  end
-
-  def iteration4
-    1.upto(3) do |n|
-      puts n.to_s
-    end
-  end
-
-  def iteration5
-    3.downto(1) do |n|
-      puts n.to_s
-    end
-  end
-
-  def iteration6
-    3.downto(1) do
-      puts "hello"
-    end
-  end
-
-  def case_stmt
-    var = 2
-    result = ""
-    case var
-    when 1 then
-      # block
-      puts "something"
-      result = "red"
-    when 2, 3 then
-      result = "yellow"
-    when 4 then
-      # nothing
-    else
-      result = "green"
-    end
-
-    case result
-    when "red" then
-      var = 1
-    when "yellow" then
-      var = 2
-    when "green" then
-      var = 3
-    end
-
-    return result
-  end
-
   # Other edge cases:
 
   def opt_args(arg1, arg2 = 42, *args)
@@ -144,26 +19,6 @@ class Something
     return "foo"
   end
 
-  def bools(arg1)
-    unless arg1.nil? then
-      return true
-    else
-      return false
-    end
-  end
-
-  def eric_is_stubborn
-    var = 42
-    var2 = var.to_s
-    $stderr.fputs(var2)
-    return var2
-  end
-
-  def interpolated
-    var = 14
-    var2 = "var is #{var}. So there."
-  end
-
   def unknown_args(arg1, arg2)
     # does nothing
     return arg1
@@ -200,48 +55,4 @@ class Something
       6
     end
   end
-
-  def op_asgn
-    a = 0
-    a ||= 1
-    a &&= 2
-    #a += 3 # doesn't use op_asgn
-
-    b = []
-    b[1] ||= 10
-    b[2] &&= 11
-    b[3] +=  12
-
-    s = Struct.new :var
-    c = s.new nil
-    c.var ||= 20
-    c.var &&= 21
-    c.var +=  22
-
-    c.d.e.f ||= 42
-
-    return a
-  end
-
-  def whiles
-    while false do
-      puts "false"
-    end
-    begin
-      puts "true"
-    end while false
-  end
-
-  def self.bmethod_maker
-    define_method(:bmethod_added) do |x|
-      x + 1
-    end
-  end
-  
-  def self.dmethod_maker
-    define_method :dmethod_added, self.method(:bmethod_maker)
-  end if RUBY_VERSION < "1.9"
-  
-  bmethod_maker
-  dmethod_maker if RUBY_VERSION < "1.9"
 end

data/test/test_parse_tree.rb

@@ -9,6 +9,7 @@ end
 
 require 'test/unit'
 require 'parse_tree'
+require 'pt_testcase'
 require 'test/something'
 
 class SomethingWithInitialize
@@ -17,26 +18,42 @@ class SomethingWithInitialize
   def protected_meth; end
 end
 
-class TestParseTree < Test::Unit::TestCase
+class ParseTree
+  def process(input) # makes it play with with ParseTreeTestCase (FIX?)
+    # um. kinda stupid, but cleaner
+    case input
+    when Array then
+      ParseTree.translate(*input)
+    else
+      ParseTree.translate(input)
+    end
+  end
+end
+
+class TestParseTree < ParseTreeTestCase
+  def setup
+    super
+    @processor = ParseTree.new(false)
+  end
 
   def test_class_initialize
     expected = [[:class, :SomethingWithInitialize, :Object,
       [:defn, :initialize, [:scope, [:block, [:args], [:nil]]]],
       [:defn, :protected_meth, [:scope, [:block, [:args], [:nil]]]],
     ]]
-    tree = @thing.parse_tree SomethingWithInitialize
+    tree = @processor.parse_tree SomethingWithInitialize
     assert_equal expected, tree
   end
 
   def test_parse_tree_for_string
-    actual   = @thing.parse_tree_for_string '1 + nil', '(string)', 1, false
+    actual   = @processor.parse_tree_for_string '1 + nil', '(string)', 1, false
     expected = [[:call, [:lit, 1], :+, [:array, [:nil]]]]
 
     assert_equal expected, actual
   end
 
   def test_parse_tree_for_string_with_newlines
-    actual   = @thing.parse_tree_for_string "1 +\n nil", 'test.rb', 5, true
+    actual   = @processor.parse_tree_for_string "1 +\n nil", 'test.rb', 5, true
     expected = [[:newline, 6, "test.rb"],
                 [:call, [:lit, 1], :+, [:array, [:nil]]]]
 
@@ -44,201 +61,20 @@ class TestParseTree < Test::Unit::TestCase
   end
 
   def test_parse_tree_for_str
-    actual   = @thing.parse_tree_for_str '1 + nil', '(string)', 1, false
+    actual   = @processor.parse_tree_for_str '1 + nil', '(string)', 1, false
     expected = [[:call, [:lit, 1], :+, [:array, [:nil]]]]
 
     assert_equal expected, actual
   end
 
-  # TODO: need a test of interpolated strings
-
   @@self_classmethod = [:defn, :"self.classmethod",
                         [:scope,
                          [:block,
                           [:args],
                           [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]]]
 
-  @@self_bmethod_maker = [:defn,
-                          :"self.bmethod_maker",
-                          [:scope,
-                           [:block,
-                            [:args],
-                            [:iter,
-                             [:fcall, :define_method,
-                              [:array, [:lit, :bmethod_added]]],
-                             [:dasgn_curr, :x],
-                             [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]]]
-
-  @@self_dmethod_maker = [:defn,
-                          :"self.dmethod_maker",
-                          [:scope,
-                           [:block,
-                            [:args],
-                            [:fcall,
-                             :define_method,
-                             [:array,
-                              [:lit, :dmethod_added],
-                              [:call, [:self], :method,
-                               [:array, [:lit, :bmethod_maker]]]]]]]]
-
   @@missing = [nil]
-  @@empty = [:defn, :empty,
-    [:scope,
-      [:block,
-        [:args],
-        [:nil]]]]
-  @@stupid = [:defn, :stupid,
-    [:scope,
-      [:block,
-        [:args],
-        [:return, [:nil]]]]]
-  @@simple = [:defn, :simple,
-    [:scope,
-      [:block,
-        [:args, :arg1],
-        [:fcall, :print,
-          [:array, [:lvar, :arg1]]],
-        [:fcall, :puts,
-          [:array,
-            [:call,
-              [:call,
-                [:lit, 4],
-                :+,
-                [:array, [:lit, 2]]],
-             :to_s]]]]]]
-  @@global = [:defn, :global,
-    [:scope,
-      [:block,
-        [:args],
-        [:call,
-          [:gvar, :$stderr],
-          :fputs,
-          [:array, [:str, "blah"]]]]]]
-  @@lasgn_call = [:defn, :lasgn_call,
-    [:scope,
-      [:block,
-        [:args],
-        [:lasgn, :c,
-          [:call,
-            [:lit, 2],
-            :+,
-            [:array, [:lit, 3]]]]]]]
-  @@conditional1 = [:defn, :conditional1,
-    [:scope,
-      [:block,
-        [:args, :arg1],
-        [:if,
-          [:call,
-            [:lvar, :arg1],
-            :==,
-            [:array, [:lit, 0]]],
-          [:return,
-            [:lit, 1]], nil]]]]
-  @@conditional2 = [:defn, :conditional2,
-    [:scope,
-      [:block,
-        [:args, :arg1],
-        [:if,
-          [:call,
-            [:lvar, :arg1],
-            :==,
-            [:array, [:lit, 0]]], nil,
-          [:return,
-            [:lit, 2]]]]]]
-  @@conditional3 = [:defn, :conditional3,
-    [:scope,
-      [:block,
-        [:args, :arg1],
-        [:if,
-          [:call,
-            [:lvar, :arg1],
-            :==,
-            [:array, [:lit, 0]]],
-          [:return,
-            [:lit, 3]],
-          [:return,
-            [:lit, 4]]]]]]
-  @@conditional4 = [:defn, :conditional4,
-    [:scope,
-      [:block,
-        [:args, :arg1],
-        [:if,
-          [:call,
-            [:lvar, :arg1],
-            :==,
-            [:array, [:lit, 0]]],
-          [:return, [:lit, 2]],
-          [:if,
-            [:call,
-              [:lvar, :arg1],
-              :<,
-              [:array, [:lit, 0]]],
-            [:return, [:lit, 3]],
-            [:return, [:lit, 4]]]]]]]
-  @@iteration_body = [:scope,
-                   [:block,
-                    [:args],
-                    [:lasgn, :array,
-                     [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
-                    [:iter,
-                     [:call,
-                      [:lvar, :array], :each],
-                     [:dasgn_curr, :x],
-                     [:block,
-                      [:dasgn_curr, :y],
-                      [:dasgn_curr, :y, [:call, [:dvar, :x], :to_s]],
-                      [:fcall, :puts, [:array, [:dvar, :y]]]]]]]
 
-  @@iteration1 = [:defn, :iteration1, @@iteration_body]
-  @@iteration2 = [:defn, :iteration2, @@iteration_body]
-  @@iteration3 = [:defn, :iteration3,
-    [:scope,
-      [:block,
-        [:args],
-        [:lasgn, :array1,
-          [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
-        [:lasgn, :array2,
-          [:array, [:lit, 4], [:lit, 5], [:lit, 6], [:lit, 7]]],
-        [:iter,
-          [:call,
-            [:lvar, :array1], :each],
-          [:dasgn_curr, :x],
-          [:iter,
-            [:call,
-              [:lvar, :array2], :each],
-            [:dasgn_curr, :y],
-            [:block,
-              [:fcall, :puts,
-                [:array, [:call, [:dvar, :x], :to_s]]],
-              [:fcall, :puts,
-                [:array, [:call, [:dvar, :y], :to_s]]]]]]]]]
-  @@iteration4 = [:defn,
- :iteration4,
- [:scope,
-  [:block,
-   [:args],
-   [:iter,
-    [:call, [:lit, 1], :upto, [:array, [:lit, 3]]],
-    [:dasgn_curr, :n],
-    [:fcall, :puts, [:array, [:call, [:dvar, :n], :to_s]]]]]]]
-  @@iteration5 = [:defn,
- :iteration5,
- [:scope,
-      [:block,
-   [:args],
-   [:iter,
-    [:call, [:lit, 3], :downto, [:array, [:lit, 1]]],
-    [:dasgn_curr, :n],
-    [:fcall, :puts, [:array, [:call, [:dvar, :n], :to_s]]]]]]]
-  @@iteration6 = [:defn,
- :iteration6,
- [:scope,
-      [:block,
-   [:args],
-   [:iter,
-    [:call, [:lit, 3], :downto, [:array, [:lit, 1]]],
-    nil,
-    [:fcall, :puts, [:array, [:str, "hello"]]]]]]]
   @@opt_args = [:defn, :opt_args,
     [:scope,
       [:block,
@@ -269,58 +105,6 @@ class TestParseTree < Test::Unit::TestCase
         [:fcall, :puts, [:array, [:call, [:lvar, :arg3], :to_s]]],
         [:return,
           [:str, "foo"]]]]]
-  @@bools = [:defn, :bools,
-    [:scope,
-      [:block,
-        [:args, :arg1],
-        [:if,
-          [:call,
-            [:lvar, :arg1], :nil?],
-          [:return,
-            [:false]],
-          [:return,
-            [:true]]]]]]
-  @@case_stmt = [:defn, :case_stmt,
-    [:scope,
-      [:block,
-        [:args],
-        [:lasgn, :var, [:lit, 2]],
-        [:lasgn, :result, [:str, ""]],
-        [:case,
-          [:lvar, :var],
-          [:when,
-            [:array, [:lit, 1]],
-            [:block,
-              [:fcall, :puts, [:array, [:str, "something"]]],
-              [:lasgn, :result, [:str, "red"]]]],
-          [:when,
-            [:array, [:lit, 2], [:lit, 3]],
-            [:lasgn, :result, [:str, "yellow"]]],
-          [:when, [:array, [:lit, 4]], nil],
-          [:lasgn, :result, [:str, "green"]]],
-        [:case,
-          [:lvar, :result],
-          [:when, [:array, [:str, "red"]], [:lasgn, :var, [:lit, 1]]],
-          [:when, [:array, [:str, "yellow"]], [:lasgn, :var, [:lit, 2]]],
-          [:when, [:array, [:str, "green"]], [:lasgn, :var, [:lit, 3]]],
-          nil],
-        [:return, [:lvar, :result]]]]]
-  @@eric_is_stubborn = [:defn,
-    :eric_is_stubborn,
-    [:scope,
-      [:block,
-        [:args],
-        [:lasgn, :var, [:lit, 42]],
-        [:lasgn, :var2, [:call, [:lvar, :var], :to_s]],
-        [:call, [:gvar, :$stderr], :fputs, [:array, [:lvar, :var2]]],
-        [:return, [:lvar, :var2]]]]]
-  @@interpolated = [:defn,
-    :interpolated,
-    [:scope,
-      [:block,
-        [:args],
-        [:lasgn, :var, [:lit, 14]],
-        [:lasgn, :var2, [:dstr, "var is ", [:lvar, :var], [:str, ". So there."]]]]]]
   @@unknown_args = [:defn, :unknown_args,
     [:scope,
       [:block,
@@ -350,30 +134,7 @@ class TestParseTree < Test::Unit::TestCase
           [:rescue,
             [:lit, 5],
             [:resbody, nil, [:lit, 6]]]]]]]
-  @@op_asgn = [:defn, :op_asgn,
-               [:scope,
-                [:block,
-                 [:args],
-                 [:lasgn, :a, [:lit, 0]],
-                 [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 1]]],
-                 [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 2]]],
 
-                 [:lasgn, :b, [:zarray]],
-
-                 [:op_asgn1, [:lvar, :b], [:array, [:lit, 1]], :"||", [:lit, 10]],
-       [:op_asgn1, [:lvar, :b], [:array, [:lit, 2]], :"&&", [:lit, 11]],
-       [:op_asgn1, [:lvar, :b], [:array, [:lit, 3]], :+, [:lit, 12]],
-
-       [:lasgn, :s, [:call, [:const, :Struct], :new, [:array, [:lit, :var]]]],
-       [:lasgn, :c, [:call, [:lvar, :s], :new, [:array, [:nil]]]],
-
-       [:op_asgn2, [:lvar, :c], :var=, :"||", [:lit, 20]],
-       [:op_asgn2, [:lvar, :c], :var=, :"&&", [:lit, 21]],
-       [:op_asgn2, [:lvar, :c], :var=, :+, [:lit, 22]],
-
-       [:op_asgn2, [:call, [:call, [:lvar, :c], :d], :e], :f=, :"||", [:lit, 42]],
-
-       [:return, [:lvar, :a]]]]]
   @@determine_args = [:defn, :determine_args,
     [:scope,
       [:block,
@@ -386,24 +147,7 @@ class TestParseTree < Test::Unit::TestCase
                 :unknown_args,
                 [:array, [:lit, 4], [:str, "known"]]]]]]]]
 
-  @@bmethod_added = [:defn,
-    :bmethod_added,
-    [:bmethod,
-      [:dasgn_curr, :x],
-      [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]
   
-  @@dmethod_added = [:defn,
- :dmethod_added,
- [:dmethod,
-  :bmethod_maker,
-  [:scope,
-   [:block,
-    [:args],
-    [:iter,
-     [:fcall, :define_method, [:array, [:lit, :bmethod_added]]],
-     [:dasgn_curr, :x],
-     [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]]]] if RUBY_VERSION < "1.9"
-
   @@attrasgn = [:defn,
     :attrasgn,
     [:scope,
@@ -415,50 +159,21 @@ class TestParseTree < Test::Unit::TestCase
           :type=, 
           [:array, [:call, [:vcall, :other], :type]]]]]]
   
-  @@whiles = [:defn,
-    :whiles,
-    [:scope,
-      [:block,
-        [:args],
-        [:while, [:false], [:fcall, :puts, [:array, [:str, "false"]]], true],
-        [:while, [:false], [:fcall, :puts, [:array, [:str, "true"]]], false]]]]
-  @@xstr = [:defn,
-    :xstr,
-    [:scope,
-      [:block,
-        [:args],
-        [:xstr, 'touch 5']]]] 
-  @@dxstr = [:defn,
-    :dxstr,
-    [:scope,
-      [:block,
-        [:args],
-        [:dxstr, 'touch ', [:lit, 5]]]]] 
-
   @@__all = [:class, :Something, :Object]
   
-  def setup
-    @thing = ParseTree.new(false)
-  end
-
-  methods = Something.instance_methods(false)
-
-  methods.sort.each do |meth|
+  Something.instance_methods(false).sort.each do |meth|
     if class_variables.include?("@@#{meth}") then
       @@__all << eval("@@#{meth}")
-      eval "def test_#{meth}; assert_equal @@#{meth}, @thing.parse_tree_for_method(Something, :#{meth}); end"
+      eval "def test_#{meth}; assert_equal @@#{meth}, @processor.parse_tree_for_method(Something, :#{meth}); end"
     else
       eval "def test_#{meth}; flunk \"You haven't added @@#{meth} yet\"; end"
     end
   end
 
-  methods = Something.singleton_methods
-
-# TODO: cleanup
-  methods.sort.each do |meth|
+  Something.singleton_methods.sort.each do |meth|
     if class_variables.include?("@@self_#{meth}") then
       @@__all << eval("@@self_#{meth}")
-      eval "def test_self_#{meth}; assert_equal @@self_#{meth}, @thing.parse_tree_for_method(Something, :#{meth}, true); end"
+      eval "def test_self_#{meth}; assert_equal @@self_#{meth}, @processor.parse_tree_for_method(Something, :#{meth}, true); end"
     else
       eval "def test_self_#{meth}; flunk \"You haven't added @@self_#{meth} yet\"; end"
     end
@@ -466,13 +181,13 @@ class TestParseTree < Test::Unit::TestCase
 
   def test_missing
     assert_equal(@@missing,
-		 @thing.parse_tree_for_method(Something, :missing),
+		 @processor.parse_tree_for_method(Something, :missing),
 		 "Must return -3 for missing methods")
   end
 
-  def test_class
+  def test_whole_class
     assert_equal([@@__all],
-		 @thing.parse_tree(Something),
+		 @processor.parse_tree(Something),
 		 "Must return a lot of shit")
   end
 end