rubinius-melbourne 2.0.0.19 → 2.0.1.0

data/spec/case_spec.rb

@@ -0,0 +1,234 @@
+describe "A Case node" do
+  relates <<-ruby do
+      var = 2
+      result = ""
+      case var
+      when 1 then
+        puts("something")
+        result = "red"
+      when 2, 3 then
+        result = "yellow"
+      when 4 then
+        # do nothing
+      else
+        result = "green"
+      end
+      case result
+      when "red" then
+        var = 1
+      when "yellow" then
+        var = 2
+      when "green" then
+        var = 3
+      else
+        # do nothing
+      end
+    ruby
+
+    parse do
+      [:block,
+       [:lasgn, :var, [:lit, 2]],
+       [:lasgn, :result, [:str, ""]],
+       [:case,
+        [:lvar, :var],
+        [:when,
+         [:array, [:lit, 1]],
+         [:block,
+          [:call, nil, :puts, [:arglist, [: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]]
+    end
+  end
+
+  relates <<-ruby do
+      case a
+      when b then
+        case
+        when (d and e) then
+          f
+        else
+          # do nothing
+        end
+      else
+        # do nothing
+      end
+    ruby
+
+    parse do
+      [:case,
+       [:call, nil, :a, [:arglist]],
+       [:when,
+        [:array, [:call, nil, :b, [:arglist]]],
+        [:case,
+         nil,
+         [:when,
+          [:array,
+           [:and,
+            [:call, nil, :d, [:arglist]],
+            [:call, nil, :e, [:arglist]]]],
+          [:call, nil, :f, [:arglist]]],
+         nil]],
+       nil]
+    end
+  end
+
+  relates <<-ruby do
+      var1 = 1
+      var2 = 2
+      result = nil
+      case var1
+      when 1 then
+        case var2
+        when 1 then
+          result = 1
+        when 2 then
+          result = 2
+        else
+          result = 3
+        end
+      when 2 then
+        case var2
+        when 1 then
+          result = 4
+        when 2 then
+          result = 5
+        else
+          result = 6
+        end
+      else
+        result = 7
+      end
+    ruby
+
+    parse do
+      [: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]]]]
+    end
+  end
+
+  relates <<-ruby do
+      case
+      when (a == 1) then
+        :a
+      when (a == 2) then
+        :b
+      else
+        :c
+      end
+    ruby
+
+    parse do
+      [:case,
+       nil,
+       [:when,
+        [:array,
+         [:call, [:call, nil, :a, [:arglist]], :==, [:arglist, [:lit, 1]]]],
+        [:lit, :a]],
+       [:when,
+        [:array,
+         [:call, [:call, nil, :a, [:arglist]], :==, [:arglist, [:lit, 2]]]],
+        [:lit, :b]],
+       [:lit, :c]]
+    end
+  end
+
+  relates <<-ruby do
+      case a
+      when :b, *c then
+        d
+      else
+        e
+      end
+    ruby
+
+    parse do
+      [:case,
+       [:call, nil, :a, [:arglist]],
+       [:when,
+        [:array, [:lit, :b], [:when, [:call, nil, :c, [:arglist]], nil]],
+        [:call, nil, :d, [:arglist]]],
+       [:call, nil, :e, [:arglist]]]
+    end
+  end
+
+  relates <<-ruby do
+      case true
+      when String, *%w(foo bar baz) then
+        12
+      end
+    ruby
+
+    parse do
+      [:case,
+       [:true],
+       [:when,
+        [:array,
+         [:const, :String],
+         [:when, [:array, [:str, "foo"], [:str, "bar"], [:str, "baz"]], nil]],
+        [:lit, 12]],
+       nil]
+    end
+  end
+
+  relates <<-ruby do
+      case ()
+      when a
+        1
+      end
+    ruby
+
+    parse do
+      [:case,
+       [:nil],
+       [:when, [:array, [:call, nil, :a, [:arglist]]], [:lit, 1]],
+       nil]
+    end
+  end
+
+  relates <<-ruby do
+      x = 1
+      case a
+      when x
+        2
+      end
+    ruby
+
+    parse do
+      [:block,
+       [:lasgn, :x, [:lit, 1]],
+       [:case,
+        [:call, nil, :a, [:arglist]],
+        [:when, [:array, [:lvar, :x]], [:lit, 2]],
+        nil]]
+    end
+  end
+end

data/spec/cdecl_spec.rb

@@ -0,0 +1,45 @@
+describe "A Cdecl node" do
+  relates "X = 42" do
+    parse do
+      [:cdecl, :X, [:lit, 42]]
+    end
+  end
+
+  relates "::X = 1" do
+    parse do
+      [:cdecl, [:colon3, :X], [:lit, 1]]
+    end
+  end
+
+  relates "X::Y = 1" do
+    parse do
+      [:cdecl, [:colon2, [:const, :X], :Y], [:lit, 1]]
+    end
+  end
+
+  relates "X::Y::Z = a" do
+    parse do
+      [:cdecl,
+       [:colon2, [:colon2, [:const, :X], :Y], :Z],
+       [:call, nil, :a, [:arglist]]]
+    end
+  end
+
+  relates "a::A = 1" do
+    parse do
+      [:cdecl, [:colon2, [:call, nil, :a, [:arglist]], :A], [:lit, 1]]
+    end
+  end
+
+  relates <<-ruby do
+      a = Object
+      a::B = b
+    ruby
+
+    parse do
+      [:block,
+       [:lasgn, :a, [:const, :Object]],
+       [:cdecl, [:colon2, [:lvar, :a], :B], [:call, nil, :b, [:arglist]]]]
+    end
+  end
+end

data/spec/class_spec.rb

@@ -0,0 +1,83 @@
+describe "A Class node" do
+  relates <<-ruby do
+      class X
+        puts((1 + 1))
+        def blah
+          puts("hello")
+        end
+      end
+    ruby
+
+    parse do
+      [:class,
+       :X,
+       nil,
+       [:scope,
+        [:block,
+         [:call,
+          nil,
+          :puts,
+          [:arglist, [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]]]],
+         [:defn,
+          :blah,
+          [:args],
+          [:scope,
+           [:block, [:call, nil, :puts, [:arglist, [:str, "hello"]]]]]]]]]
+    end
+  end
+
+  relates <<-ruby do
+      class ::Y
+        c
+      end
+    ruby
+
+    parse do
+      [:class, [:colon3, :Y], nil, [:scope, [:call, nil, :c, [:arglist]]]]
+    end
+  end
+
+  relates <<-ruby do
+      class X::Y
+        c
+      end
+    ruby
+
+    parse do
+      [:class,
+       [:colon2, [:const, :X], :Y],
+       nil,
+       [:scope, [:call, nil, :c, [:arglist]]]]
+    end
+  end
+
+  relates <<-ruby do
+      class X < Array
+      end
+    ruby
+
+    parse do
+      [:class, :X, [:const, :Array], [:scope]]
+    end
+  end
+
+  relates <<-ruby do
+      class X < expr
+      end
+    ruby
+
+    parse do
+      [:class, :X, [:call, nil, :expr, [:arglist]], [:scope]]
+    end
+  end
+
+  relates <<-ruby do
+      class X < Object
+      end
+    ruby
+
+    parse do
+      [:class, :X, [:const, :Object], [:scope]]
+    end
+  end
+end

data/spec/colon2_spec.rb

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

data/spec/colon3_spec.rb

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

data/spec/const_spec.rb

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

data/spec/custom/matchers/parse_as.rb

@@ -0,0 +1,27 @@
+# The ParseAsMatcher wraps the logic for checking that a string of Ruby code
+# is converted to the expected s-expression. It is combined with the #parse_as
+# spec helper and enables specs of the form:
+#
+#   "a = 1".should parse_as([:lasgn, :a, [:lit, 1]])
+#
+class ParseAsMatcher
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual.to_sexp.to_a
+    @actual == @expected
+  end
+
+  def failure_message
+    ["Expected:\n#{@actual.pretty_inspect}\n",
+     "to equal:\n#{@expected.pretty_inspect}"]
+  end
+end
+
+class Object
+  def parse_as(sexp)
+    ParseAsMatcher.new sexp
+  end
+end

data/spec/custom/runner/relates.rb

@@ -0,0 +1,83 @@
+# SpecDataRelation enables concise specs that involve several different forms
+# of the same data. This is specifically useful for the parser and compiler
+# specs where the output of each stage is essentially related to the input
+# Ruby source. Together with the #relates spec method, it enables specs like:
+#
+#   describe "An If node" do
+#     relates "a if b" do
+#       parse do
+#         # return the expected sexp
+#       end
+#
+#       compile do |g|
+#         # return the expected bytecode
+#       end
+#
+#       jit do |as|
+#         # return the expected asm/machine code
+#       end
+#     end
+#
+#     relates "if a; b; end" do
+#       # ...
+#     end
+#   end
+
+class SpecDataRelation
+  # Provides a simple configurability so that any one or more of the possible
+  # processes can be run. See the custom options in custom/utils/options.rb.
+  def self.enable(process)
+    @processors ||= []
+    @processors << process
+  end
+
+  # Returns true if no process is specifically set or if +process+ is in the
+  # list of enabled processes. In other words, all processes are enabled by
+  # default, or any combination of them may be enabled.
+  def self.enabled?(process)
+    @processors.nil? or @processors.include?(process)
+  end
+
+  def initialize(ruby)
+    @ruby = ruby
+  end
+
+  # Formats the Ruby source code for reabable output in the -fs formatter
+  # option. If the source contains no newline characters, wraps the source in
+  # single quotes to set if off from the rest of the description string. If
+  # the source does contain newline characters, sets the indent level to four
+  # characters.
+  def format(ruby)
+    if /\n/ =~ ruby
+      lines = ruby.rstrip.lines
+      if /( *)/ =~ lines.first
+        if $1.size > 4
+          dedent = $1.size - 4
+          ruby = lines.map { |l| l[dedent..-1] }.join
+        else
+          indent = " " * (4 - $1.size)
+          ruby = lines.map { |l| "#{indent}#{l}" }.join
+        end
+      end
+      "\n#{ruby}"
+    else
+      "'#{ruby}'"
+    end
+  end
+
+  # Creates spec example blocks if the parse process is enabled.
+  def parse(&block)
+    return unless self.class.enabled? :parser
+
+    ruby = @ruby
+    it "is parsed from #{format ruby}" do
+      ruby.should parse_as(block.call)
+    end
+  end
+end
+
+class Object
+  def relates(str, &block)
+    SpecDataRelation.new(str).instance_eval(&block)
+  end
+end