rubinius-melbourne 2.0.1.0 → 2.1.0.0

data/spec/colon2_spec.rb

@@ -1,7 +1,5 @@
 describe "A Colon2 node" do
-  relates "X::Y" do
-    parse do
-      [:colon2, [:const, :X], :Y]
-    end
+  parse "X::Y" do
+    [:colon2, [:const, :X], :Y]
   end
 end

data/spec/colon3_spec.rb

@@ -1,7 +1,5 @@
 describe "A Colon3 node" do
-  relates "::X" do
-    parse do
-      [:colon3, :X]
-    end
+  parse "::X" do
+    [:colon3, :X]
   end
 end

data/spec/const_spec.rb

@@ -1,7 +1,5 @@
 describe "A Const node" do
-  relates "X" do
-    parse do
-      [:const, :X]
-    end
+  parse "X" do
+    [:const, :X]
   end
 end

data/spec/custom/runner/relates.rb

@@ -80,4 +80,8 @@ class Object
   def relates(str, &block)
     SpecDataRelation.new(str).instance_eval(&block)
   end
+
+  def parse(str, &block)
+    SpecDataRelation.new(str).parse(&block)
+  end
 end

data/spec/cvar_spec.rb

@@ -1,29 +1,23 @@
 describe "A Cvar node" do
-  relates "@@x" do
-    parse do
-      [:cvar, :@@x]
-    end
+  parse "@@x" do
+    [:cvar, :@@x]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       class A
         @@a
       end
     ruby
 
-    parse do
-      [:class, :A, nil, [:scope, [:cvar, :@@a]]]
-    end
+    [:class, :A, nil, [:scope, [:block, [:cvar, :@@a]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       module M
         @@a
       end
     ruby
 
-    parse do
-      [:module, :M, [:scope, [:cvar, :@@a]]]
-    end
+    [:module, :M, [:scope, [:block, [:cvar, :@@a]]]]
   end
 end

data/spec/cvasgn_spec.rb

@@ -1,30 +1,35 @@
 describe "A Cvasgn node" do
-  relates <<-ruby do
+  parse <<-ruby do
       def x
         @@blah = 1
       end
     ruby
 
-    parse do
-      [:defn,
-       :x,
-       [:args],
-       [:scope, [:block, [:cvasgn, :@@blah, [:lit, 1]]]]]
-    end
+    [:defn,
+     :x,
+     [:args],
+     [:scope, [:block, [:cvasgn, :@@blah, [:lit, 1]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def self.quiet_mode=(boolean)
         @@quiet_mode = boolean
       end
     ruby
 
-    parse do
-      [:defs,
-       [:self],
-       :quiet_mode=,
-       [:args, :boolean],
-       [:scope, [:block, [:cvasgn, :@@quiet_mode, [:lvar, :boolean]]]]]
-    end
+    [:defs,
+     [:self],
+     :quiet_mode=,
+     [:args, :boolean],
+     [:scope, [:block, [:cvasgn, :@@quiet_mode, [:lvar, :boolean]]]]]
+  end
+
+  parse <<-ruby do
+      class X
+        @@blah = 1
+      end
+    ruby
+
+    [:class, :X, nil, [:scope, [:block, [:cvasgn, :@@blah, [:lit, 1]]]]]
   end
 end

data/spec/defined_spec.rb

@@ -1,117 +1,119 @@
 describe "A Defined node" do
-  relates "defined? $x" do
-    parse do
-      [:defined, [:gvar, :$x]]
-    end
+  parse "defined? $x" do
+    [:defined, [:gvar, :$x]]
   end
 
-  relates "defined? a" do
-    # TODO
+  parse "defined? a" do
+    [:defined, [:call, nil, :a, [:arglist]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       a = 1
       defined? a
     ruby
+
+    [:block, [:lasgn, :a, [:lit, 1]], [:defined, [:lvar, :a]]]
   end
 
-  relates "defined? x = 1" do
-    # TODO
+  parse "defined? x = 1" do
+    [:defined, [:lasgn, :x, [:lit, 1]]]
   end
 
-  relates "defined? x += 1" do
-    # TODO
+  parse "defined? x += 1" do
+    [:defined, [:lasgn, :x, [:call, [:lvar, :x], :+, [:arglist, [:lit, 1]]]]]
   end
 
-  relates "defined? x ||= 1" do
-    # TODO
+  parse "defined? x ||= 1" do
+    [:defined, [:op_asgn_or, [:lvar, :x], [:lasgn, :x, [:lit, 1]]]]
   end
 
-  relates "defined? x &&= 1" do
-    # TODO
+  parse "defined? x &&= 1" do
+    [:defined, [:op_asgn_and, [:lvar, :x], [:lasgn, :x, [:lit, 1]]]]
   end
 
-  relates "defined? X" do
-    # TODO
+  parse "defined? X" do
+    [:defined, [:const, :X]]
   end
 
-  relates "defined? ::X" do
-    # TODO
+  parse "defined? ::X" do
+    [:defined, [:colon3, :X]]
   end
 
-  relates "defined? X::Y" do
-    # TODO
+  parse "defined? X::Y" do
+    [:defined, [:colon2, [:const, :X], :Y]]
   end
 
-  relates "defined? X::Y::Z" do
-    # TODO
+  parse "defined? X::Y::Z" do
+    [:defined, [:colon2, [:colon2, [:const, :X], :Y], :Z]]
   end
 
-  relates "defined? self::A" do
-    # TODO
+  parse "defined? self::A" do
+    [:defined, [:colon2, [:self], :A]]
   end
 
-  relates "defined? self" do
-    # TODO
+  parse "defined? self" do
+    [:defined, [:self]]
   end
 
-  relates "defined? true" do
-    # TODO
+  parse "defined? true" do
+    [:defined, [:true]]
   end
 
-  relates "defined? false" do
-    # TODO
+  parse "defined? false" do
+    [:defined, [:false]]
   end
 
-  relates "defined? nil" do
-    # TODO
+  parse "defined? nil" do
+    [:defined, [:nil]]
   end
 
-  relates "defined? @var" do
-    # TODO
+  parse "defined? @var" do
+    [:defined, [:ivar, :@var]]
   end
 
-  relates "defined? @@var" do
-    # TODO
+  parse "defined? @@var" do
+    [:defined, [:cvar, :@@var]]
   end
 
-  relates "defined? :a" do
-    # TODO
+  parse "defined? :a" do
+    [:defined, [:lit, :a]]
   end
 
-  relates "defined? 'a'" do
-    # TODO
+  parse "defined? 'a'" do
+    [:defined, [:str, "a"]]
   end
 
-  relates "defined? 0" do
-    # TODO
+  parse "defined? 0" do
+    [:defined, [:lit, 0]]
   end
 
-  relates "defined? yield" do
-    # TODO
+  parse "defined? yield" do
+    [:defined, [:yield]]
   end
 
-  relates "defined? A.m" do
-    # TODO
+  parse "defined? A.m" do
+    [:defined, [:call, [:const, :A], :m, [:arglist]]]
   end
 
-  relates "defined? ::A.m" do
-    # TODO
+  parse "defined? ::A.m" do
+    [:defined, [:call, [:colon3, :A], :m, [:arglist]]]
   end
 
-  relates "defined? A::B.m" do
-    # TODO
+  parse "defined? A::B.m" do
+    [:defined, [:call, [:colon2, [:const, :A], :B], :m, [:arglist]]]
   end
 
-  relates "defined? a.b" do
-    # TODO
+  parse "defined? a.b" do
+    [:defined, [:call, [:call, nil, :a, [:arglist]], :b, [:arglist]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       a = 1
       defined? a.to_s
     ruby
 
-    # TODO
+    [:block,
+     [:lasgn, :a, [:lit, 1]],
+     [:defined, [:call, [:lvar, :a], :to_s, [:arglist]]]]
   end
 end

data/spec/defn_spec.rb

@@ -1,17 +1,15 @@
 describe "A Defn node" do
-  relates <<-ruby do
+  parse <<-ruby do
       def m
         begin
         end
       end
     ruby
 
-    parse do
-      [:defn, :m, [:args], [:scope, [:block, [:nil]]]]
-    end
+    [:defn, :m, [:args], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def m
         return :a
       ensure
@@ -19,53 +17,52 @@ describe "A Defn node" do
       end
     ruby
 
-    # TODO
+    [:defn,
+     :m,
+     [:args],
+     [:scope, [:block, [:ensure, [:return, [:lit, :a]], [:return, [:lit, :b]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def blah(*args, &block)
         other(42, *args, &block)
       end
     ruby
 
-    parse do
-      [:defn,
-       :blah,
-       [:args, :"*args", :"&block"],
-       [:scope,
-        [:block,
-         [:call,
-          nil,
-          :other,
-          [:arglist,
-           [:lit, 42],
-           [:splat, [:lvar, :args]],
-           [:block_pass, [:lvar, :block]]]]]]]
-    end
+    [:defn,
+     :blah,
+     [:args, :"*args", :"&block"],
+     [:scope,
+      [:block,
+       [:call,
+        nil,
+        :other,
+        [:arglist,
+         [:lit, 42],
+         [:splat, [:lvar, :args]],
+         [:block_pass, [:lvar, :block]]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def blah(*args, &block)
         other(*args, &block)
       end
     ruby
 
-    parse do
-      [:defn,
-       :blah,
-       [:args, :"*args", :"&block"],
-       [:scope,
-        [:block,
-         [:call,
-          nil,
-          :other,
-          [:arglist,
-           [:splat, [:lvar, :args]],
-           [:block_pass, [:lvar, :block]]]]]]]
-    end
+    [:defn,
+     :blah,
+     [:args, :"*args", :"&block"],
+     [:scope,
+      [:block,
+       [:call,
+        nil,
+        :other,
+        [:arglist,
+         [:splat, [:lvar, :args]],
+         [:block_pass, [:lvar, :block]]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f
         begin
           b
@@ -77,20 +74,20 @@ describe "A Defn node" do
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args],
-       [:scope,
-        [:block,
-         [:rescue,
-          [:call, nil, :b, [:arglist]],
-          [:resbody, [:array], [:call, nil, :c, [:arglist]]]],
-         [:call, nil, :d, [:arglist]]]]]
-    end
+    [:defn,
+     :f,
+     [:args],
+     [:scope,
+      [:block,
+       [:rescue,
+        [:call, nil, :b, [:arglist]],
+        [:resbody,
+         [:array, [:const, :StandardError]],
+         [:call, nil, :c, [:arglist]]]],
+       [:call, nil, :d, [:arglist]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f
         a
         begin
@@ -101,20 +98,20 @@ describe "A Defn node" do
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args],
-       [:scope,
-        [:block,
-         [:call, nil, :a, [:arglist]],
-         [:rescue,
-          [:call, nil, :b, [:arglist]],
-          [:resbody, [:array], [:call, nil, :c, [:arglist]]]]]]]
-    end
+    [:defn,
+     :f,
+     [:args],
+     [:scope,
+      [:block,
+       [:call, nil, :a, [:arglist]],
+       [:rescue,
+        [:call, nil, :b, [:arglist]],
+        [:resbody,
+         [:array, [:const, :StandardError]],
+         [:call, nil, :c, [:arglist]]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f
         a
         begin
@@ -126,277 +123,235 @@ describe "A Defn node" do
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args],
-       [:scope,
-        [:block,
-         [:call, nil, :a, [:arglist]],
-         [:rescue,
-          [:call, nil, :b, [:arglist]],
-          [:resbody, [:array], [:call, nil, :c, [:arglist]]]],
-         [:call, nil, :d, [:arglist]]]]]
-    end
+    [:defn,
+     :f,
+     [:args],
+     [:scope,
+      [:block,
+       [:call, nil, :a, [:arglist]],
+       [:rescue,
+        [:call, nil, :b, [:arglist]],
+        [:resbody,
+         [:array, [:const, :StandardError]],
+         [:call, nil, :c, [:arglist]]]],
+       [:call, nil, :d, [:arglist]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(&block)
       end
     ruby
 
-    parse do
-      [:defn, :f, [:args, :"&block"], [:scope, [:block, [:nil]]]]
-    end
+    [:defn, :f, [:args, :"&block"], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(mand, opt = 42, &block)
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args, :mand, :opt, :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]],
-       [:scope, [:block, [:nil]]]]
-    end
+    [:defn,
+     :f,
+     [:args, :mand, :opt, :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(x, a=x.b)
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args, :x, :a, [:block, [:lasgn, :a, [:call, [:lvar, :x], :b, [:arglist]]]]],
-       [:scope, [:block, [:nil]]]]
-    end
+    [:defn,
+     :f,
+     [:args, :x, :a, [:block, [:lasgn, :a, [:call, [:lvar, :x], :b, [:arglist]]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(mand, &block)
       end
     ruby
 
-    parse do
-      [:defn, :f, [:args, :mand, :"&block"], [:scope, [:block, [:nil]]]]
-    end
+    [:defn, :f, [:args, :mand, :"&block"], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(mand, opt = 42)
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args, :mand, :opt, [:block, [:lasgn, :opt, [:lit, 42]]]],
-       [:scope, [:block, [:nil]]]]
-    end
+    [:defn,
+     :f,
+     [:args, :mand, :opt, [:block, [:lasgn, :opt, [:lit, 42]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(mand, opt = 42, *rest, &block)
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args,
-        :mand,
-        :opt,
-        :"*rest",
-        :"&block",
-        [:block, [:lasgn, :opt, [:lit, 42]]]],
-       [:scope, [:block, [:nil]]]]
-    end
+    [:defn,
+     :f,
+     [:args,
+      :mand,
+      :opt,
+      :"*rest",
+      :"&block",
+      [:block, [:lasgn, :opt, [:lit, 42]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def x(a, b = 42, *)
       end
     ruby
 
-    parse do
-      [:defn,
-       :x,
-       [:args, :a, :b, :*, [:block, [:lasgn, :b, [:lit, 42]]]],
-       [:scope, [:block, [:nil]]]]
-    end
+    [:defn,
+     :x,
+     [:args, :a, :b, :*, [:block, [:lasgn, :b, [:lit, 42]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(mand, opt = 42, *rest)
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args, :mand, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]],
-       [:scope, [:block, [:nil]]]]
-    end
+    [:defn,
+     :f,
+     [:args, :mand, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def empty
       end
     ruby
 
-    parse do
-      [:defn, :empty, [:args], [:scope, [:block, [:nil]]]]
-    end
+    [:defn, :empty, [:args], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(mand)
       end
     ruby
 
-    parse do
-      [:defn, :f, [:args, :mand], [:scope, [:block, [:nil]]]]
-    end
+    [:defn, :f, [:args, :mand], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(mand, *rest, &block)
       end
     ruby
 
-    parse do
-      [:defn, :f, [:args, :mand, :"*rest", :"&block"], [:scope, [:block, [:nil]]]]
-    end
+    [:defn, :f, [:args, :mand, :"*rest", :"&block"], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def x(a, *args)
         p(a, args)
       end
     ruby
 
-    parse do
-      [:defn,
-       :x,
-       [:args, :a, :"*args"],
-       [:scope, [:block, [:call, nil, :p, [:arglist, [:lvar, :a], [:lvar, :args]]]]]]
-    end
+    [:defn,
+     :x,
+     [:args, :a, :"*args"],
+     [:scope, [:block, [:call, nil, :p, [:arglist, [:lvar, :a], [:lvar, :args]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(mand, *rest)
       end
     ruby
 
-    parse do
-      [:defn, :f, [:args, :mand, :"*rest"], [:scope, [:block, [:nil]]]]
-    end
+    [:defn, :f, [:args, :mand, :"*rest"], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(opt = 42, &block)
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args, :opt, :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]],
-       [:scope, [:block, [:nil]]]]
-    end
+    [:defn,
+     :f,
+     [:args, :opt, :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(a = 42, b = '1', c=lambda {|n| n })
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args,
-        :a,
-        :b,
+    [:defn,
+     :f,
+     [:args,
+      :a,
+      :b,
+      :c,
+      [:block,
+       [:lasgn, :a, [:lit, 42]],
+       [:lasgn, :b, [:str, "1"]],
+       [:lasgn,
         :c,
-        [:block,
-         [:lasgn, :a, [:lit, 42]],
-         [:lasgn, :b, [:str, "1"]],
-         [:lasgn,
-          :c,
-          [:iter, [:call, nil, :lambda, [:arglist]], [:lasgn, :n], [:lvar, :n]]]]],
-       [:scope, [:block, [:nil]]]]
-    end
-
-    # defn args opt lambda
+        [:call, nil, :lambda, [:arglist, [:iter, [:args, :n], [:lvar, :n]]]]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(opt = 42)
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args, :opt, [:block, [:lasgn, :opt, [:lit, 42]]]],
-       [:scope, [:block, [:nil]]]]
-    end
+    [:defn,
+     :f,
+     [:args, :opt, [:block, [:lasgn, :opt, [:lit, 42]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(opt = 42, *rest, &block)
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args, :opt, :"*rest", :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]],
-       [:scope, [:block, [:nil]]]]
-    end
+    [:defn,
+     :f,
+     [:args, :opt, :"*rest", :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def x(b = 42, *)
       end
     ruby
 
-    parse do
-      [:defn,
-       :x,
-       [:args, :b, :*, [:block, [:lasgn, :b, [:lit, 42]]]],
-       [:scope, [:block, [:nil]]]]
-    end
+    [:defn,
+     :x,
+     [:args, :b, :*, [:block, [:lasgn, :b, [:lit, 42]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(opt = 42, *rest)
       end
     ruby
 
-    parse do
-      [:defn,
-       :f,
-       [:args, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]],
-       [:scope, [:block, [:nil]]]]
-    end
+    [:defn,
+     :f,
+     [:args, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def |(o)
       end
     ruby
 
-    parse do
-      [:defn, :|, [:args, :o], [:scope, [:block, [:nil]]]]
-    end
+    [:defn, :|, [:args, :o], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def eql?(resource)
         (self.uuid == resource.uuid)
       rescue
@@ -404,81 +359,69 @@ describe "A Defn node" do
       end
     ruby
 
-    parse do
-      [:defn,
-       :eql?,
-       [:args, :resource],
-       [:scope,
-        [:block,
-         [:rescue,
-          [:call,
-           [:call, [:self], :uuid, [:arglist]],
-           :==,
-           [:arglist, [:call, [:lvar, :resource], :uuid, [:arglist]]]],
-          [:resbody, [:array], [:false]]]]]]
-    end
+    [:defn,
+     :eql?,
+     [:args, :resource],
+     [:scope,
+      [:block,
+       [:rescue,
+        [:call,
+         [:call, [:self], :uuid, [:arglist]],
+         :==,
+         [:arglist, [:call, [:lvar, :resource], :uuid, [:arglist]]]],
+        [:resbody, [:array, [:const, :StandardError]], [:false]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def something?
       end
     ruby
 
-    parse do
-      [:defn, :something?, [:args], [:scope, [:block, [:nil]]]]
-    end
+    [:defn, :something?, [:args], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def x(*)
       end
     ruby
 
-    parse do
-      [:defn, :x, [:args, :*], [:scope, [:block, [:nil]]]]
-    end
+    [:defn, :x, [:args, :*], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def f(*rest)
       end
     ruby
 
-    parse do
-      [:defn, :f, [:args, :"*rest"], [:scope, [:block, [:nil]]]]
-    end
+    [:defn, :f, [:args, :"*rest"], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def x(a, *)
         p(a)
       end
     ruby
 
-    parse do
-      [:defn,
-       :x,
-       [:args, :a, :*],
-       [:scope, [:block, [:call, nil, :p, [:arglist, [:lvar, :a]]]]]]
-    end
+    [:defn,
+     :x,
+     [:args, :a, :*],
+     [:scope, [:block, [:call, nil, :p, [:arglist, [:lvar, :a]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def zarray
         a = []
         return a
       end
     ruby
 
-    parse do
-      [:defn,
-       :zarray,
-       [:args],
-       [:scope, [:block, [:lasgn, :a, [:array]], [:return, [:lvar, :a]]]]]
-    end
+    [:defn,
+     :zarray,
+     [:args],
+     [:scope, [:block, [:lasgn, :a, [:array]], [:return, [:lvar, :a]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       b = 42
       def a
         c do
@@ -491,64 +434,59 @@ describe "A Defn node" do
       end
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :b, [:lit, 42]],
-       [:defn,
-        :a,
-        [:args],
-        [:scope,
-         [:block,
+    [:block,
+     [:lasgn, :b, [:lit, 42]],
+     [:defn,
+      :a,
+      [:args],
+      [:scope,
+       [:block,
+        [:call,
+         nil,
+         :c,
+         [:arglist,
           [:iter,
-           [:call, nil, :c, [:arglist]],
-           nil,
+           [:args],
            [:rescue,
             [:call, nil, :do_stuff, [:arglist]],
             [:resbody,
              [:array, [:const, :RuntimeError], [:lasgn, :b, [:gvar, :$!]]],
-             [:call, nil, :puts, [:arglist, [:lvar, :b]]]]]]]]]]
-    end
+             [:call, nil, :puts, [:arglist, [:lvar, :b]]]]]]]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def x(a=0.0,b=0.0)
         a+b
       end
     ruby
 
-    parse do
-      [:defn,
-       :x,
-       [:args,
-        :a,
-        :b,
-        [:block, [:lasgn, :a, [:lit, 0.0]], [:lasgn, :b, [:lit, 0.0]]]],
-       [:scope, [:block, [:call, [:lvar, :a], :+, [:arglist, [:lvar, :b]]]]]]
-    end
+    [:defn,
+     :x,
+     [:args,
+      :a,
+      :b,
+      [:block, [:lasgn, :a, [:lit, 0.0]], [:lasgn, :b, [:lit, 0.0]]]],
+     [:scope, [:block, [:call, [:lvar, :a], :+, [:arglist, [:lvar, :b]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def x(*b)
         a(*b)
       end
     ruby
 
-    parse do
-      [:defn,
-       :x,
-       [:args, :"*b"],
-       [:scope, [:block, [:call, nil, :a, [:arglist, [:splat, [:lvar, :b]]]]]]]
-    end
+    [:defn,
+     :x,
+     [:args, :"*b"],
+     [:scope, [:block, [:call, nil, :a, [:arglist, [:splat, [:lvar, :b]]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def meth(b)
         b
       end
     ruby
 
-    parse do
-      [:defn, :meth, [:args, :b], [:scope, [:block, [:lvar, :b]]]]
-    end
+    [:defn, :meth, [:args, :b], [:scope, [:block, [:lvar, :b]]]]
   end
 end