rubinius-melbourne 2.3.1.0 → 3.0

data/spec/case_spec.rb

@@ -1,216 +0,0 @@
-describe "A Case node" do
-  parse <<-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
-
-    [: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
-
-  parse <<-ruby do
-      case a
-      when b then
-        case
-        when (d and e) then
-          f
-        else
-          # do nothing
-        end
-      else
-        # do nothing
-      end
-    ruby
-
-    [: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
-
-  parse <<-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
-
-    [: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
-
-  parse <<-ruby do
-      case
-      when (a == 1) then
-        :a
-      when (a == 2) then
-        :b
-      else
-        :c
-      end
-    ruby
-
-    [: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
-
-  parse <<-ruby do
-      case a
-      when :b, *c then
-        d
-      else
-        e
-      end
-    ruby
-
-    [:case,
-     [:call, nil, :a, [:arglist]],
-     [:when,
-      [:array, [:lit, :b], [:when, [:call, nil, :c, [:arglist]], nil]],
-      [:call, nil, :d, [:arglist]]],
-     [:call, nil, :e, [:arglist]]]
-  end
-
-  parse <<-ruby do
-      case true
-      when String, *%w(foo bar baz) then
-        12
-      end
-    ruby
-
-    [:case,
-     [:true],
-     [:when,
-      [:array, [:const, :String], [:str, "foo"], [:str, "bar"], [:str, "baz"]],
-      [:lit, 12]],
-     nil]
-  end
-
-  parse <<-ruby do
-      case ()
-      when a
-        1
-      end
-    ruby
-
-    [:case,
-     [:nil],
-     [:when, [:array, [:call, nil, :a, [:arglist]]], [:lit, 1]],
-     nil]
-  end
-
-  parse <<-ruby do
-      x = 1
-      case a
-      when x
-        2
-      end
-    ruby
-
-    [:block,
-     [:lasgn, :x, [:lit, 1]],
-     [:case,
-      [:call, nil, :a, [:arglist]],
-      [:when, [:array, [:lvar, :x]], [:lit, 2]],
-      nil]]
-  end
-end

data/spec/cdecl_spec.rb

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

data/spec/class_spec.rb

@@ -1,71 +0,0 @@
-describe "A Class node" do
-  parse <<-ruby do
-      class X
-        puts((1 + 1))
-        def blah
-          puts("hello")
-        end
-      end
-    ruby
-
-    [: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
-
-  parse <<-ruby do
-      class ::Y
-        c
-      end
-    ruby
-
-    [:class, [:colon3, :Y], nil, [:scope, [:block, [:call, nil, :c, [:arglist]]]]]
-  end
-
-  parse <<-ruby do
-      class X::Y
-        c
-      end
-    ruby
-
-    [:class,
-     [:colon2, [:const, :X], :Y],
-     nil,
-     [:scope, [:block, [:call, nil, :c, [:arglist]]]]]
-  end
-
-  parse <<-ruby do
-      class X < Array
-      end
-    ruby
-
-    [:class, :X, [:const, :Array], [:scope]]
-  end
-
-  parse <<-ruby do
-      class X < expr
-      end
-    ruby
-
-    [:class, :X, [:call, nil, :expr, [:arglist]], [:scope]]
-  end
-
-  parse <<-ruby do
-      class X < Object
-      end
-    ruby
-
-    [:class, :X, [:const, :Object], [:scope]]
-  end
-end

data/spec/colon2_spec.rb

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

data/spec/colon3_spec.rb

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

data/spec/const_spec.rb

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

data/spec/custom/matchers/parse_as.rb

@@ -1,28 +0,0 @@
-# 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)
-    parse = CodeTools::Melbourne.parse_string actual
-    @actual = parse.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

@@ -1,87 +0,0 @@
-# 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
-
-  def parse(str, &block)
-    SpecDataRelation.new(str).parse(&block)
-  end
-end