rubinius-melbourne 2.0.1.0 → 2.1.0.0

data/spec/match2_spec.rb

@@ -1,19 +1,15 @@
 describe "A Match2 node" do
-  relates '/x/ =~ "blah"' do
-    parse do
-      [:match2, [:regex, "x", 0], [:str, "blah"]]
-    end
+  parse '/x/ =~ "blah"' do
+    [:match2, [:regex, "x", 0], [:str, "blah"]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       x = "x"
       /\#{x}/ =~ x
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :x, [:str, "x"]],
-       [:match2, [:dregx, "", [:evstr, [:lvar, :x]]], [:lvar, :x]]]
-    end
+    [:block,
+     [:lasgn, :x, [:str, "x"]],
+     [:match2, [:dregx, "", [:evstr, [:lvar, :x]]], [:lvar, :x]]]
   end
 end

data/spec/match3_spec.rb

@@ -1,24 +1,20 @@
 describe "A Match3 node" do
-  relates '"blah" =~ /x/' do
-    parse do
-      [:match3, [:regex, "x", 0], [:str, "blah"]]
-    end
+  parse '"blah" =~ /x/' do
+    [:match3, [:regex, "x", 0], [:str, "blah"]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       a = 'abc'
       if a =~ /\#{a}/
         1
       end
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :a, [:str, "abc"]],
-       [:if,
-        [:match3, [:dregx, "", [:evstr, [:lvar, :a]]], [:lvar, :a]],
-        [:lit, 1],
-        nil]]
-    end
+    [:block,
+     [:lasgn, :a, [:str, "abc"]],
+     [:if,
+      [:match3, [:dregx, "", [:evstr, [:lvar, :a]]], [:lvar, :a]],
+      [:lit, 1],
+      nil]]
   end
 end

data/spec/match_spec.rb

@@ -1,7 +1,5 @@
 describe "A Match node" do
-  relates "1 if /x/" do
-    parse do
-      [:if, [:match, [:regex, "x", 0]], [:lit, 1], nil]
-    end
+  parse "1 if /x/" do
+    [:if, [:match, [:regex, "x", 0]], [:lit, 1], nil]
   end
 end

data/spec/module_spec.rb

@@ -1,47 +1,43 @@
 describe "A Module node" do
-  relates <<-ruby do
+  parse <<-ruby do
       module X
         def y
         end
       end
     ruby
 
-    parse do
-      [:module, :X, [:scope, [:defn, :y, [:args], [:scope, [:block, [:nil]]]]]]
-    end
+    [:module,
+    :X,
+    [:scope, [:block, [:defn, :y, [:args], [:scope, [:block, [:nil]]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       module ::Y
         c
       end
     ruby
 
-    parse do
-      [:module, [:colon3, :Y], [:scope, [:call, nil, :c, [:arglist]]]]
-    end
+    [:module, [:colon3, :Y], [:scope, [:block, [:call, nil, :c, [:arglist]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       module X::Y
         c
       end
     ruby
 
-    parse do
-      [:module, [:colon2, [:const, :X], :Y], [:scope, [:call, nil, :c, [:arglist]]]]
-    end
+    [:module,
+     [:colon2, [:const, :X], :Y],
+     [:scope, [:block, [:call, nil, :c, [:arglist]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       "prevent the above from infecting rdoc"
 
       module Graffle
       end
     ruby
 
-    parse do
-      [:module, :Graffle, [:scope]]
-    end
+    [:module, :Graffle, [:scope]]
   end
 end

data/spec/nil_spec.rb

@@ -1,7 +1,5 @@
 describe "A Nil node" do
-  relates "nil" do
-    parse do
-      [:nil]
-    end
+  parse "nil" do
+    [:nil]
   end
 end

data/spec/not_spec.rb

@@ -1,17 +1,15 @@
 describe "A Not node" do
-  relates "(not true)" do
-    parse do
-      [:not, [:true]]
-    end
+  parse "(not true)" do
+    [:call, [:true], :!, [:arglist]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       a = 1
       b = !a
     ruby
 
-    parse do
-      [:block, [:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:not, [:lvar, :a]]]]
-    end
+    [:block,
+     [:lasgn, :a, [:lit, 1]],
+     [:lasgn, :b, [:call, [:lvar, :a], :!, [:arglist]]]]
   end
 end

data/spec/nth_ref_spec.rb

@@ -1,7 +1,5 @@
 describe "An Nth_ref node" do
-  relates "$1" do
-    parse do
-      [:nth_ref, 1]
-    end
+  parse "$1" do
+    [:nth_ref, 1]
   end
 end

data/spec/op_asgn_spec.rb

@@ -1,127 +1,103 @@
 describe "An Op_asgn1 node" do
-  relates "a &&= 8" do
-    parse do
-      [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 8]]]
-    end
+  parse "a &&= 8" do
+    [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 8]]]
   end
 
-  relates "hsh[:blah] ||= 8" do
-    parse do
-      [:op_asgn1,
-       [:call, nil, :hsh, [:arglist]],
-       [:arglist, [:lit, :blah]],
-       :"||",
-       [:lit, 8]]
-    end
+  parse "hsh[:blah] ||= 8" do
+    [:op_asgn1,
+     [:call, nil, :hsh, [:arglist]],
+     [:arglist, [:lit, :blah]],
+     :"||",
+     [:lit, 8]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       x = 1
       hsh[x] ||= 8
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :x, [:lit, 1]],
-       [:op_asgn1,
-        [:call, nil, :hsh, [:arglist]],
-        [:arglist, [:lvar, :x]],
-        :"||",
-        [:lit, 8]]]
-    end
+    [:block,
+     [:lasgn, :x, [:lit, 1]],
+     [:op_asgn1,
+      [:call, nil, :hsh, [:arglist]],
+      [:arglist, [:lvar, :x]],
+      :"||",
+      [:lit, 8]]]
   end
 
-  relates "hsh[:blah] &&= 8" do
-    parse do
-      [:op_asgn1,
-       [:call, nil, :hsh, [:arglist]],
-       [:arglist, [:lit, :blah]],
-       :"&&",
-       [:lit, 8]]
-    end
+  parse "hsh[:blah] &&= 8" do
+    [:op_asgn1,
+     [:call, nil, :hsh, [:arglist]],
+     [:arglist, [:lit, :blah]],
+     :"&&",
+     [:lit, 8]]
   end
 
-  relates "hsh[:blah] ^= 8" do
-    parse do
-      [:op_asgn1,
-       [:call, nil, :hsh, [:arglist]],
-       [:arglist, [:lit, :blah]],
-       :^,
-       [:lit, 8]]
-    end
+  parse "hsh[:blah] ^= 8" do
+    [:op_asgn1,
+     [:call, nil, :hsh, [:arglist]],
+     [:arglist, [:lit, :blah]],
+     :^,
+     [:lit, 8]]
   end
 
-  relates "ary[0,1] += [4]" do
-    parse do
-      [:op_asgn1,
-       [:call, nil, :ary, [:arglist]],
-       [:arglist, [:lit, 0], [:lit, 1]],
-       :+,
-       [:array, [:lit, 4]]]
-    end
+  parse "ary[0,1] += [4]" do
+    [:op_asgn1,
+     [:call, nil, :ary, [:arglist]],
+     [:arglist, [:lit, 0], [:lit, 1]],
+     :+,
+     [:array, [:lit, 4]]]
   end
 
-  relates "x.val ||= 6" do
-    parse do
-      [:op_asgn2, [:call, nil, :x, [:arglist]], :val=, :"||", [:lit, 6]]
-    end
+  parse "x.val ||= 6" do
+    [:op_asgn2, [:call, nil, :x, [:arglist]], :val=, :"||", [:lit, 6]]
   end
 
-  relates "x.val &&= 7" do
-    parse do
-      [:op_asgn2, [:call, nil, :x, [:arglist]], :val=, :"&&", [:lit, 7]]
-    end
+  parse "x.val &&= 7" do
+    [:op_asgn2, [:call, nil, :x, [:arglist]], :val=, :"&&", [:lit, 7]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       @b = []
       @b[1] ||= 10
       @b[2] &&= 11
       @b[3] += 12
     ruby
 
-    parse do
-      [:block,
-       [:iasgn, :@b, [:array]],
-       [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 1]], :"||", [:lit, 10]],
-       [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 2]], :"&&", [:lit, 11]],
-       [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 3]], :+, [:lit, 12]]]
-    end
+    [:block,
+     [:iasgn, :@b, [:array]],
+     [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 1]], :"||", [:lit, 10]],
+     [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 2]], :"&&", [:lit, 11]],
+     [:op_asgn1, [:ivar, :@b], [:arglist, [:lit, 3]], :+, [:lit, 12]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       b = []
       b[1] ||= 10
       b[2] &&= 11
       b[3] += 12
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :b, [:array]],
-       [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 1]], :"||", [:lit, 10]],
-       [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 2]], :"&&", [:lit, 11]],
-       [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 3]], :+, [:lit, 12]]]
-    end
+    [:block,
+     [:lasgn, :b, [:array]],
+     [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 1]], :"||", [:lit, 10]],
+     [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 2]], :"&&", [:lit, 11]],
+     [:op_asgn1, [:lvar, :b], [:arglist, [:lit, 3]], :+, [:lit, 12]]]
   end
 end
 
 describe "An Op_asgn2 node" do
-  relates "x.val ^= 8" do
-    parse do
-      [:op_asgn2, [:call, nil, :x, [:arglist]], :val=, :^, [:lit, 8]]
-    end
+  parse "x.val ^= 8" do
+    [:op_asgn2, [:call, nil, :x, [:arglist]], :val=, :^, [:lit, 8]]
   end
 
-  relates "self.Bag ||= Bag.new" do
-    parse do
-      [:op_asgn2,
-        [:self],
-        :"Bag=", :"||", [:call, [:const, :Bag], :new, [:arglist]]]
-    end
+  parse "self.Bag ||= Bag.new" do
+    [:op_asgn2,
+      [:self],
+      :"Bag=", :"||", [:call, [:const, :Bag], :new, [:arglist]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       s = Struct.new(:var)
       c = s.new(nil)
       c.var ||= 20
@@ -130,67 +106,57 @@ describe "An Op_asgn2 node" do
       c.d.e.f ||= 42
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :s, [:call, [:const, :Struct], :new, [:arglist, [:lit, :var]]]],
-       [:lasgn, :c, [:call, [:lvar, :s], :new, [:arglist, [: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, [:arglist]], :e, [:arglist]],
-        :f=,
-        :"||",
-        [:lit, 42]]]
-    end
+    [:block,
+     [:lasgn, :s, [:call, [:const, :Struct], :new, [:arglist, [:lit, :var]]]],
+     [:lasgn, :c, [:call, [:lvar, :s], :new, [:arglist, [: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, [:arglist]], :e, [:arglist]],
+      :f=,
+      :"||",
+      [:lit, 42]]]
   end
 end
 
 describe "An Op_asgn_and node" do
-  relates "@fetcher &&= new(Gem.configuration[:http_proxy])" do
-    parse do
-      [:op_asgn_and,
-       [:ivar, :@fetcher],
-       [:iasgn,
-        :@fetcher,
+  parse "@fetcher &&= new(Gem.configuration[:http_proxy])" do
+    [:op_asgn_and,
+     [:ivar, :@fetcher],
+     [:iasgn,
+      :@fetcher,
+      [:call,
+       nil,
+       :new,
+       [:arglist,
         [:call,
-         nil,
-         :new,
-         [:arglist,
-          [:call,
-           [:call, [:const, :Gem], :configuration, [:arglist]],
-           :[],
-           [:arglist, [:lit, :http_proxy]]]]]]]
-    end
+         [:call, [:const, :Gem], :configuration, [:arglist]],
+         :[],
+         [:arglist, [:lit, :http_proxy]]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       a = 0
       a &&= 2
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :a, [:lit, 0]],
-       [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 2]]]]
-    end
+    [:block,
+     [:lasgn, :a, [:lit, 0]],
+     [:op_asgn_and, [:lvar, :a], [:lasgn, :a, [:lit, 2]]]]
   end
 end
 
 describe "An Op_asgn_or node" do
-  relates "@@var ||= 3" do
-    parse do
-      [:op_asgn_or, [:cvar, :@@var], [:cvdecl, :@@var, [:lit, 3]]]
-    end
+  parse "@@var ||= 3" do
+    [:op_asgn_or, [:cvar, :@@var], [:cvasgn, :@@var, [:lit, 3]]]
   end
 
-  relates "a ||= 8" do
-    parse do
-      [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 8]]]
-    end
+  parse "a ||= 8" do
+    [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 8]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       a ||= begin
               b
             rescue
@@ -198,49 +164,43 @@ describe "An Op_asgn_or node" do
             end
     ruby
 
-    parse do
-      [:op_asgn_or,
-       [:lvar, :a],
-       [:lasgn,
-        :a,
-        [:rescue,
-         [:call, nil, :b, [:arglist]],
-         [:resbody, [:array], [:call, nil, :c, [:arglist]]]]]]
-    end
-  end
-
-  relates "@fetcher ||= new(Gem.configuration[:http_proxy])" do
-    parse do
-      [:op_asgn_or,
-       [:ivar, :@fetcher],
-       [:iasgn,
-        :@fetcher,
+    [:op_asgn_or,
+     [:lvar, :a],
+     [:lasgn,
+      :a,
+      [:rescue,
+       [:call, nil, :b, [:arglist]],
+       [:resbody,
+        [:array, [:const, :StandardError]],
+        [:call, nil, :c, [:arglist]]]]]]
+  end
+
+  parse "@fetcher ||= new(Gem.configuration[:http_proxy])" do
+    [:op_asgn_or,
+     [:ivar, :@fetcher],
+     [:iasgn,
+      :@fetcher,
+      [:call,
+       nil,
+       :new,
+       [:arglist,
         [:call,
-         nil,
-         :new,
-         [:arglist,
-          [:call,
-           [:call, [:const, :Gem], :configuration, [:arglist]],
-           :[],
-           [:arglist, [:lit, :http_proxy]]]]]]]
-    end
+         [:call, [:const, :Gem], :configuration, [:arglist]],
+         :[],
+         [:arglist, [:lit, :http_proxy]]]]]]]
   end
 
-  relates "@v ||= {  }" do
-    parse do
-      [:op_asgn_or, [:ivar, :@v], [:iasgn, :@v, [:hash]]]
-    end
+  parse "@v ||= {  }" do
+    [:op_asgn_or, [:ivar, :@v], [:iasgn, :@v, [:hash]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       a = 0
       a ||= 1
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :a, [:lit, 0]],
-       [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 1]]]]
-    end
+    [:block,
+     [:lasgn, :a, [:lit, 0]],
+     [:op_asgn_or, [:lvar, :a], [:lasgn, :a, [:lit, 1]]]]
   end
 end