rubinius-melbourne 2.0.1.0 → 2.1.0.0

data/spec/defs_spec.rb

@@ -1,20 +1,18 @@
 describe "A Defs node" do
-  relates <<-ruby do
+  parse <<-ruby do
       def self.x(y)
         (y + 1)
       end
     ruby
 
-    parse do
-      [:defs,
-         [:self],
-         :x,
-         [:args, :y],
-         [:scope, [:block, [:call, [:lvar, :y], :+, [:arglist, [:lit, 1]]]]]]
-    end
+    [:defs,
+       [:self],
+       :x,
+       [:args, :y],
+       [:scope, [:block, [:call, [:lvar, :y], :+, [:arglist, [:lit, 1]]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def self.setup(ctx)
         bind = allocate
         bind.context = ctx
@@ -22,60 +20,54 @@ describe "A Defs node" do
       end
     ruby
 
-    parse do
-      [:defs,
-         [:self],
-         :setup,
-         [:args, :ctx],
-         [:scope,
-          [:block,
-           [:lasgn, :bind, [:call, nil, :allocate, [:arglist]]],
-           [:attrasgn, [:lvar, :bind], :context=, [:arglist, [:lvar, :ctx]]],
-           [:return, [:lvar, :bind]]]]]
-    end
+    [:defs,
+       [:self],
+       :setup,
+       [:args, :ctx],
+       [:scope,
+        [:block,
+         [:lasgn, :bind, [:call, nil, :allocate, [:arglist]]],
+         [:attrasgn, [:lvar, :bind], :context=, [:arglist, [:lvar, :ctx]]],
+         [:return, [:lvar, :bind]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def self.empty(*)
       end
     ruby
 
-    parse do
-      [:defs, [:self], :empty, [:args, :*], [:scope, [:block]]]
-    end
+    [:defs, [:self], :empty, [:args, :*], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def self.empty
       end
     ruby
 
-    parse do
-      [:defs, [:self], :empty, [:args], [:scope, [:block]]]
-    end
+    [:defs, [:self], :empty, [:args], [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       def (a.b).empty(*)
       end
     ruby
 
-    parse do
-      [:defs,
-       [:call, [:call, nil, :a, [:arglist]], :b, [:arglist]],
-       :empty,
-       [:args, :*],
-       [:scope, [:block]]]
-    end
+    [:defs,
+     [:call, [:call, nil, :a, [:arglist]], :b, [:arglist]],
+     :empty,
+     [:args, :*],
+     [:scope, [:block, [:nil]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
     x = "a"
     def x.m(a)
       a
     end
     ruby
 
-    # TODO
+    [:block,
+     [:lasgn, :x, [:str, "a"]],
+     [:defs, [:lvar, :x], :m, [:args, :a], [:scope, [:block, [:lvar, :a]]]]]
   end
 end

data/spec/dot2_spec.rb

@@ -1,7 +1,5 @@
 describe "A Dot2 node" do
-  relates "(a..b)" do
-    parse do
-      [:dot2, [:call, nil, :a, [:arglist]], [:call, nil, :b, [:arglist]]]
-    end
+  parse "(a..b)" do
+    [:dot2, [:call, nil, :a, [:arglist]], [:call, nil, :b, [:arglist]]]
   end
 end

data/spec/dot3_spec.rb

@@ -1,7 +1,5 @@
 describe "A Dot3 node" do
-  relates "(a...b)" do
-    parse do
-      [:dot3, [:call, nil, :a, [:arglist]], [:call, nil, :b, [:arglist]]]
-    end
+  parse "(a...b)" do
+    [:dot3, [:call, nil, :a, [:arglist]], [:call, nil, :b, [:arglist]]]
   end
 end

data/spec/dregx_spec.rb

@@ -1,52 +1,38 @@
 describe "A Dregx node" do
-  relates <<-ruby do
+  parse <<-ruby do
       /(\#{})/
     ruby
 
-    parse do
-      [:dregx, "(", [:str, ""], [:str, ")"]]
-    end
+    [:dregx, "(", [:evstr, [:nil]], [:str, ")"]]
   end
 
-  relates "/x\#{(1 + 1)}y/" do
-    parse do
-      [:dregx,
-       "x",
-       [:evstr, [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]]],
-       [:str, "y"]]
-    end
+  parse "/x\#{(1 + 1)}y/" do
+    [:dregx,
+     "x",
+     [:evstr, [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]]],
+     [:str, "y"]]
   end
 
-  relates "/a\#{}b/" do
-    parse do
-      [:dregx, "a", [:str, ""], [:str, "b"]]
-    end
+  parse "/a\#{}b/" do
+    [:dregx, "a", [:evstr, [:nil]], [:str, "b"]]
   end
 
-  relates "/\#{@rakefile}/" do
-    parse do
-      [:dregx, "", [:evstr, [:ivar, :@rakefile]]]
-    end
+  parse "/\#{@rakefile}/" do
+    [:dregx, "", [:evstr, [:ivar, :@rakefile]]]
   end
 
-  relates "/\#{1}/n" do
-    parse do
-      [:dregx, "", [:evstr, [:lit, 1]], 16]
-    end
+  parse "/\#{1}/n" do
+    [:dregx, "", [:evstr, [:lit, 1]], 512]
   end
 
-  relates "/\#{IAC}\#{SB}/no" do
-    parse do
-      [:dregx_once, "", [:evstr, [:const, :IAC]], [:evstr, [:const, :SB]], 16]
-    end
+  parse "/\#{IAC}\#{SB}/no" do
+    [:dregx_once, "", [:evstr, [:const, :IAC]], [:evstr, [:const, :SB]], 512]
   end
 
-  relates "/x\#{(1 + 1)}y/o" do
-    parse do
-      [:dregx_once,
-       "x",
-       [:evstr, [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]]],
-       [:str, "y"]]
-    end
+  parse "/x\#{(1 + 1)}y/o" do
+    [:dregx_once,
+     "x",
+     [:evstr, [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]]],
+     [:str, "y"]]
   end
 end

data/spec/dstr_spec.rb

@@ -1,169 +1,145 @@
 describe "A Dstr node" do
-  relates <<-ruby do
+  parse <<-ruby do
       "hello \#{}"
     ruby
 
-    parse do
-      [:dstr, "hello ", [:str, ""]]
-    end
+    [:dstr, "hello ", [:evstr, [:nil]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       argl = 1
       "x\#{argl}y"
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :argl, [:lit, 1]],
-       [:dstr, "x", [:evstr, [:lvar, :argl]], [:str, "y"]]]
-    end
+    [:block,
+     [:lasgn, :argl, [:lit, 1]],
+     [:dstr, "x", [:evstr, [:lvar, :argl]], [:str, "y"]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       argl = 1
       "x\#{("%.2f" % 3.14159)}y"
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :argl, [:lit, 1]],
-       [:dstr,
-        "x",
-        [:evstr, [:call, [:str, "%.2f"], :%, [:arglist, [:lit, 3.14159]]]],
-        [:str, "y"]]]
-    end
+    [:block,
+     [:lasgn, :argl, [:lit, 1]],
+     [:dstr,
+      "x",
+      [:evstr, [:call, [:str, "%.2f"], :%, [:arglist, [:lit, 3.14159]]]],
+      [:str, "y"]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       max = 2
       argl = 1
       "x\#{("%.\#{max}f" % 3.14159)}y"
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :max, [:lit, 2]],
-       [:lasgn, :argl, [:lit, 1]],
-       [:dstr,
-        "x",
-        [:evstr,
-         [:call,
-          [:dstr, "%.", [:evstr, [:lvar, :max]], [:str, "f"]],
-          :%,
-          [:arglist, [:lit, 3.14159]]]],
-        [:str, "y"]]]
-    end
+    [:block,
+     [:lasgn, :max, [:lit, 2]],
+     [:lasgn, :argl, [:lit, 1]],
+     [:dstr,
+      "x",
+      [:evstr,
+       [:call,
+        [:dstr, "%.", [:evstr, [:lvar, :max]], [:str, "f"]],
+        :%,
+        [:arglist, [:lit, 3.14159]]]],
+      [:str, "y"]]]
   end
 
-  relates '"#{22}aa" "cd#{44}" "55" "#{66}"' do
-    parse do
-      [:dstr,
-       "",
-       [:evstr, [:lit, 22]],
-       [:str, "aa"],
-       [:str, "cd"],
-       [:evstr, [:lit, 44]],
-       [:str, "55"],
-       [:evstr, [:lit, 66]]]
-    end
+  parse '"#{22}aa" "cd#{44}" "55" "#{66}"' do
+    [:dstr,
+     "",
+     [:evstr, [:lit, 22]],
+     [:str, "aa"],
+     [:str, "cd"],
+     [:evstr, [:lit, 44]],
+     [:str, "55"],
+     [:evstr, [:lit, 66]]]
   end
 
-  relates '"a #$global b #@ivar c #@@cvar d"' do
-    parse do
-      [:dstr,
-       "a ",
-       [:evstr, [:gvar, :$global]],
-       [:str, " b "],
-       [:evstr, [:ivar, :@ivar]],
-       [:str, " c "],
-       [:evstr, [:cvar, :@@cvar]],
-       [:str, " d"]]
-    end
+  parse '"a #$global b #@ivar c #@@cvar d"' do
+    [:dstr,
+     "a ",
+     [:evstr, [:gvar, :$global]],
+     [:str, " b "],
+     [:evstr, [:ivar, :@ivar]],
+     [:str, " c "],
+     [:evstr, [:cvar, :@@cvar]],
+     [:str, " d"]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
 <<EOM
   blah
 \#{1 + 1}blah
 EOM
     ruby
 
-    parse do
-      [:dstr,
-       "  blah\n",
-       [:evstr, [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]]],
-       [:str, "blah\n"]]
-    end
+    [:dstr,
+     "  blah\n",
+     [:evstr, [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]]],
+     [:str, "blah\n"]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
 <<-EOF
 def test_\#{action}_valid_feed
 EOF
     ruby
 
-    parse do
-      [:dstr,
-       "def test_",
-       [:evstr, [:call, nil, :action, [:arglist]]],
-       [:str, "_valid_feed\n"]]
-    end
+    [:dstr,
+     "def test_",
+     [:evstr, [:call, nil, :action, [:arglist]]],
+     [:str, "_valid_feed\n"]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
 <<-EOF
 s1 '\#{RUBY_PLATFORM}' s2
 \#{__FILE__}
 EOF
     ruby
 
-    parse do
-      [:dstr,
-       "s1 '",
-       [:evstr, [:const, :RUBY_PLATFORM]],
-       [:str, "' s2\n"],
-       [:evstr, [:file]],
-       [:str, "\n"]]
-    end
+    [:dstr,
+     "s1 '",
+     [:evstr, [:const, :RUBY_PLATFORM]],
+     [:str, "' s2\n"],
+     [:evstr, [:file]],
+     [:str, "\n"]]
   end
 
-  relates "%Q[before [\#{nest}] after]" do
-    parse do
-      [:dstr,
-       "before [",
-       [:evstr, [:call, nil, :nest, [:arglist]]],
-       [:str, "] after"]]
-    end
+  parse "%Q[before [\#{nest}] after]" do
+    [:dstr,
+     "before [",
+     [:evstr, [:call, nil, :nest, [:arglist]]],
+     [:str, "] after"]]
   end
 
-  relates '"#{"blah"}#{__FILE__}:#{__LINE__}: warning: #{$!.message} (#{$!.class})"' do
-    parse do
-      [:dstr,
-       "blah",
-       [:evstr, [:file]],
-       [:str, ":"],
-       [:evstr, [:lit, 1]],
-       [:str, ": warning: "],
-       [:evstr, [:call, [:gvar, :$!], :message, [:arglist]]],
-       [:str, " ("],
-       [:evstr, [:call, [:gvar, :$!], :class, [:arglist]]],
-       [:str, ")"]]
-    end
+  parse '"#{"blah"}#{__FILE__}:#{__LINE__}: warning: #{$!.message} (#{$!.class})"' do
+    [:dstr,
+     "blah",
+     [:evstr, [:file]],
+     [:str, ":"],
+     [:evstr, [:lit, 1]],
+     [:str, ": warning: "],
+     [:evstr, [:call, [:gvar, :$!], :message, [:arglist]]],
+     [:str, " ("],
+     [:evstr, [:call, [:gvar, :$!], :class, [:arglist]]],
+     [:str, ")"]]
   end
 
-  relates '"before #{from} middle #{to} (#{__FILE__}:#{__LINE__})"' do
-    parse do
-      [:dstr,
-       "before ",
-       [:evstr, [:call, nil, :from, [:arglist]]],
-       [:str, " middle "],
-       [:evstr, [:call, nil, :to, [:arglist]]],
-       [:str, " ("],
-       [:evstr, [:file]],
-       [:str, ":"],
-       [:evstr, [:lit, 1]],
-       [:str, ")"]]
-    end
+  parse '"before #{from} middle #{to} (#{__FILE__}:#{__LINE__})"' do
+    [:dstr,
+     "before ",
+     [:evstr, [:call, nil, :from, [:arglist]]],
+     [:str, " middle "],
+     [:evstr, [:call, nil, :to, [:arglist]]],
+     [:str, " ("],
+     [:evstr, [:file]],
+     [:str, ":"],
+     [:evstr, [:lit, 1]],
+     [:str, ")"]]
   end
 end