test/pt_testcase.rb in ParseTree-1.6.3 vs test/pt_testcase.rb in ParseTree-1.6.4
- old
+ new
@@ -4,25 +4,23 @@
class Examples
attr_reader :reader
attr_writer :writer
- def a_method; 1+1; end
+ def a_method(x); x+1; end
alias an_alias a_method
- def self.bmethod_maker
- define_method(:bmethod_added) do |x|
- x + 1
- end
+ define_method(:unsplatted) do |x|
+ x + 1
end
- def self.dmethod_maker
- define_method :dmethod_added, self.method(:bmethod_maker)
- end if RUBY_VERSION < "1.9"
+ define_method :splatted do |*args|
+ y = args.first
+ y + 42
+ end
- bmethod_maker
- dmethod_maker if RUBY_VERSION < "1.9"
+ define_method :dmethod_added, instance_method(:a_method) if RUBY_VERSION < "1.9"
end
class ParseTreeTestCase < Test::Unit::TestCase
attr_accessor :processor # to be defined by subclass
@@ -62,11 +60,11 @@
"alias" => {
"Ruby" => "class X\n alias :y :x\nend",
"ParseTree" => [:class, :X, nil,
[:scope, [:alias, [:lit, :y], [:lit, :x]]]],
- "Ruby2Ruby" => "class X\n alias_method :y, :x\nend", # FIX dbl \n
+ "Ruby2Ruby" => "class X\n alias_method :y, :x\nend",
},
"and" => {
"Ruby" => "(a and b)",
"ParseTree" => [:and, [:vcall, :a], [:vcall, :b]],
@@ -130,27 +128,39 @@
"Ruby" => "a(&b)",
"ParseTree" => [:block_pass, [:vcall, :b], [:fcall, :a]],
},
"bmethod" => {
- "Ruby" => [Examples, :bmethod_added],
+ "Ruby" => [Examples, :unsplatted],
"ParseTree" => [:defn,
- :bmethod_added,
+ :unsplatted,
[:bmethod,
[:dasgn_curr, :x],
[:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]],
- "Ruby2Ruby" => "def bmethod_added(x)\n (x + 1)\nend"
+ "Ruby2Ruby" => "def unsplatted(x)\n (x + 1)\nend"
},
+ "bmethod_splat" => {
+ "Ruby" => [Examples, :splatted],
+ "ParseTree" => [:defn, :splatted,
+ [:bmethod,
+ [:masgn, [:dasgn_curr, :args]],
+ [:block,
+ [:dasgn_curr, :y],
+ [:dasgn_curr, :y, [:call, [:dvar, :args], :first]],
+ [:call, [:dvar, :y], :+, [:array, [:lit, 42]]]]]],
+ "Ruby2Ruby" => "def splatted(*args)\n y = args.first\n (y + 42)\nend",
+ },
+
"break" => {
- "Ruby" => "loop do\n if true then\n break\n end\nend",
+ "Ruby" => "loop do\n break if true\nend",
"ParseTree" => [:iter,
[:fcall, :loop], nil, [:if, [:true], [:break], nil]],
},
"break_arg" => {
- "Ruby" => "loop do\n if true then\n break 42\n end\nend",
+ "Ruby" => "loop do\n break 42 if true\nend",
"ParseTree" => [:iter,
[:fcall, :loop], nil,
[:if, [:true], [:break, [:lit, 42]], nil]],
},
@@ -195,10 +205,37 @@
[:when, [:array, [:str, "green"]],
[:lasgn, :var, [:lit, 3]]],
nil]]
},
+ "case_nested" => {
+ "Ruby" => "var1 = 1\nvar2 = 2\nresult = nil\ncase var1\nwhen 1 then\n case var2\n when 1 then\n result = 1\n when 2 then\n result = 2\n else\n result = 3\n end\nwhen 2 then\n case var2\n when 1 then\n result = 4\n when 2 then\n result = 5\n else\n result = 6\n end\nelse\n result = 7\nend\n",
+ "ParseTree" => [:block,
+ [:lasgn, :var1, [:lit, 1]],
+ [:lasgn, :var2, [:lit, 2]],
+ [:lasgn, :result, [:nil]],
+ [:case,
+ [:lvar, :var1],
+ [:when, [:array, [:lit, 1]],
+ [:case,
+ [:lvar, :var2],
+ [:when, [:array, [:lit, 1]],
+ [:lasgn, :result, [:lit, 1]]],
+ [:when, [:array, [:lit, 2]],
+ [:lasgn, :result, [:lit, 2]]],
+ [:lasgn, :result, [:lit, 3]]]],
+ [:when, [:array, [:lit, 2]],
+ [:case,
+ [:lvar, :var2],
+ [:when, [:array, [:lit, 1]],
+ [:lasgn, :result, [:lit, 4]]],
+ [:when, [:array, [:lit, 2]],
+ [:lasgn, :result, [:lit, 5]]],
+ [:lasgn, :result, [:lit, 6]]]],
+ [:lasgn, :result, [:lit, 7]]]]
+ },
+
"case_no_expr" => { # TODO: nested
"Ruby" => "case\nwhen 1 then\n :a\nwhen 2 then\n :b\nelse\n :c\nend",
"ParseTree" => [:case, nil,
[:when,
[:array, [:lit, 1]],
@@ -261,20 +298,20 @@
"colon3" => {
"Ruby" => "::X",
"ParseTree" => [:colon3, :X],
},
- "conditional1" => {
- "Ruby" => "if (42 == 0) then\n return 1\nend",
+ "conditional1" => { # TODO: rename
+ "Ruby" => "return 1 if (42 == 0)",
"ParseTree" => [:if,
[:call, [:lit, 42], :==, [:array, [:lit, 0]]],
[:return, [:lit, 1]],
nil],
},
- "conditional2" => {
- "Ruby" => "unless (42 == 0) then\n return 2\nend",
+ "conditional2" => { # TODO: remove
+ "Ruby" => "return 2 unless (42 == 0)",
"ParseTree" => [:if,
[:call, [:lit, 42], :==, [:array, [:lit, 0]]],
nil,
[:return, [:lit, 2]]],
},
@@ -297,11 +334,11 @@
[:return, [:lit, 4]]]],
"Ruby2Ruby" => "if (42 == 0) then\n return 2\nelse\n if (42 < 0) then\n return 3\n else\n return 4\n end\nend",
},
"conditional5" => {
- "Ruby" => "unless true then\n if false then\n return\n end\nend",
+ "Ruby" => "return if false unless true",
"ParseTree" => [:if, [:true], nil, [:if, [:false], [:return], nil]],
},
"const" => {
"Ruby" => "X",
@@ -336,10 +373,22 @@
[:dasgn_curr, :y],
[:dasgn, :x,
[:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]],
},
+ "dasgn_curr" => {
+ "Ruby" => "data.each do |x, y|\n a = 1\n b = a\n b = a = x\nend",
+ "ParseTree" => [:iter,
+ [:call, [:vcall, :data], :each],
+ [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :y]]],
+ [:block,
+ [:dasgn_curr, :a, [:dasgn_curr, :b]],
+ [:dasgn_curr, :a, [:lit, 1]],
+ [:dasgn_curr, :b, [:dvar, :a]],
+ [:dasgn_curr, :b, [:dasgn_curr, :a, [:dvar, :x]]]]],
+ },
+
"defined" => {
"Ruby" => "defined? $x",
"ParseTree" => [:defined, [:gvar, :$x]],
},
@@ -378,10 +427,19 @@
"defn_or" => {
"Ruby" => "def |(o)\n # do nothing\nend",
"ParseTree" => [:defn, :|, [:scope, [:block, [:args, :o], [:nil]]]],
},
+ "defn_rescue" => {
+ "Ruby" => "def blah\n 42\n rescue\n 24\nend",
+ "ParseTree" => [:defn, :blah,
+ [:scope, [:block, [:args],
+ [:rescue,
+ [:lit, 42],
+ [:resbody, nil, [:lit, 24]]]]]],
+ },
+
"defn_zarray" => { # tests memory allocation for returns
"Ruby" => "def zarray\n a = []\n return a\nend",
"ParseTree" => [:defn, :zarray,
[:scope,
[:block, [:args],
@@ -400,19 +458,15 @@
"dmethod" => {
"Ruby" => [Examples, :dmethod_added],
"ParseTree" => [:defn,
:dmethod_added,
[:dmethod,
- :bmethod_maker,
+ :a_method,
[:scope,
[:block,
- [:args],
- [:iter,
- [:fcall, :define_method,
- [:array, [:lit, :bmethod_added]]],
- [:dasgn_curr, :x],
- [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]]]]],
+ [:args, :x],
+ [:call, [:lvar, :x], :+, [:array, [:lit, 1]]]]]]],
"Ruby2Ruby" => "def dmethod_added(x)\n (x + 1)\nend"
},
"dot2" => {
"Ruby" => "(a..b)",
@@ -492,13 +546,13 @@
"Ruby" => [Examples, :an_alias],
"ParseTree" => [:defn, :an_alias,
[:fbody,
[:scope,
[:block,
- [:args],
- [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]]]],
- "Ruby2Ruby" => "def an_alias\n (1 + 1)\nend"
+ [:args, :x],
+ [:call, [:lvar, :x], :+, [:array, [:lit, 1]]]]]]],
+ "Ruby2Ruby" => "def an_alias(x)\n (x + 1)\nend"
},
"fcall" => {
"Ruby" => "p(4)",
"ParseTree" => [:fcall, :p, [:array, [:lit, 4]]],
@@ -714,11 +768,11 @@
"ParseTree" => [:masgn,
[:array, [:lasgn, :a], [:iasgn, :@b]],
[:array, [:vcall, :c], [:vcall, :d]]],
},
"match" => {
- "Ruby" => "if /x/ then\n 1\nend",
+ "Ruby" => "1 if /x/",
"ParseTree" => [:if, [:match, [:lit, /x/]], [:lit, 1], nil],
},
"match2" => {
"Ruby" => "/x/ =~ \"blah\"",
@@ -736,11 +790,11 @@
[:scope,
[:defn, :y, [:scope, [:block, [:args], [:nil]]]]]],
},
"next" => {
- "Ruby" => "loop do\n if false then\n next\n end\nend",
+ "Ruby" => "loop do\n next if false\nend",
"ParseTree" => [:iter,
[:fcall, :loop],
nil,
[:if, [:false], [:next], nil]],
},
@@ -827,10 +881,10 @@
[:dasgn_curr, :x],
[:call, [:dvar, :x], :+, [:array, [:lit, 1]]]],
},
"redo" => {
- "Ruby" => "loop do\n if false then\n redo\n end\nend",
+ "Ruby" => "loop do\n redo if false\nend",
"ParseTree" => [:iter,
[:fcall, :loop], nil, [:if, [:false], [:redo], nil]],
},
"rescue" => {