rubinius-melbourne 2.0.1.0 → 2.1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b66e13de74897f9ce250c9cc03854b5480e213ba
-  data.tar.gz: a3a1a4673bd4180440e30721f24e47349ec6a272
+  metadata.gz: ab46989de9cf438aa41258bcf6c0eabdb44fc2fe
+  data.tar.gz: d4eee71dff3c1745ff2c8d7524182d2b9408b39a
 SHA512:
-  metadata.gz: 75897ae8e978ad3a8f18e4294fda365b0056b7408761db2d14fce91427ce06136dd20a9664af38104a0e2abbfbcdf5d74a94b1a202d1e26ab8b704b8e19dcb01
-  data.tar.gz: 5ddd5b9db0e47cab21cd29fb5aead3fa646ec370660668829baf10056b862aec7ee41eaa879ad1a4977a52a64ec2026d40a855d75e88fb93d0f79db88e25337a
+  metadata.gz: 8f4d8503d000603f8c0760372e22d76b81ae95de93178f3b83a51cd782d14099c7b7a1144299c4c8c043fece64d4d56f5051889a30c075a8dda596628dcecc09
+  data.tar.gz: 4171fddd5c644bcbcfad31906fda6c97e78f736dac199c53da8e938e83e1eb78f6379fa9599b5e7ab057500c0145966cec13d291b7baf9465eff6628eb9caedf

data/.gitignore

@@ -21,3 +21,4 @@ tmp
 .rbx
 Makefile
 namespace.h
+.spec_ruby_version

data/.travis.yml

@@ -1,14 +1,7 @@
 language: ruby
 env:
   - MELBOURNE_SPEC_VERSION=1 RUBYLIB=lib:.
-  - MELBOURNE_SPEC_VERSION=1 RUBYLIB=.
-script: bundle exec mspec spec
+before_install: gem install rubinius-toolset
 rvm:
-  - 2.0.0
+  - 2.1.0
   - rbx-2
-matrix:
-  exclude:
-    - rvm: ruby-head
-      env: MELBOURNE_SPEC_VERSION=1 RUBYLIB=lib:.
-    - rvm: rbx-2
-      env: MELBOURNE_SPEC_VERSION=1 RUBYLIB=.

data/Gemfile

@@ -2,7 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rubinius-melbourne.gemspec
 gemspec
-
-platforms :rbx do
-  gem 'rubysl', '~> 2.0'
-end

data/Rakefile

@@ -1,33 +1,40 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
-require "redcard"
 
-if RedCard.check :rubinius
-  namespace :spec do
-    desc "Build the parser extension"
-    task :build do
-      Dir.chdir "ext/rubinius/melbourne" do
-        ruby "-v extconf.rb"
-        ruby "-e 'system %[make && make install]'"
+def extension_dir
+  Dir.chdir "ext/rubinius/melbourne" do
+    yield
+  end
+end
+
+def spec_ruby_version
+  ".spec_ruby_version"
+end
+
+namespace :spec do
+  desc "Clean the parser extension"
+  task :clean do
+    extension_dir do
+      unless File.exist? spec_ruby_version and
+             File.read(spec_ruby_version) == RUBY_DESCRIPTION
+        sh "make distclean"
+        File.open(spec_ruby_version, "w") { |f| f.write RUBY_DESCRIPTION }
       end
     end
+  end
 
-    desc "Load the perser into the Spec ToolSet"
-    task :toolset do
-      Rubinius::ToolSet.start
-      require "rubinius/melbourne"
-      Rubinius::ToolSet.finish :spec
+  desc "Build the parser extension"
+  task :build do
+    extension_dir do
+      ruby "-v extconf.rb"
+      ruby "-e 'system %[make && make install]'"
     end
   end
-
-  dependencies = %w[spec:build spec:toolset]
-else
-  dependencies = []
 end
 
 desc "Run the specs"
-task :spec => dependencies do
-  sh "mspec spec"
+task :spec => %w[spec:clean spec:build] do
+  sh "mspec -r spec/spec_helper spec"
 end
 
 task :default => :spec

data/ext/rubinius/melbourne/extconf.rb

@@ -1,10 +1,11 @@
 require 'rbconfig'
 
-# Fake out Rubinius::ToolSet for bootstrapping
+# Fake out Rubinius::ToolSets for bootstrapping
 module Rubinius
-  module ToolSet
+  module ToolSets
     def self.current
       @current ||= Module.new
+      @current.const_set :ToolSet, @current
     end
   end
 end
@@ -13,7 +14,7 @@ require File.expand_path("../../../../lib/rubinius/melbourne/version", __FILE__)
 
 path = File.expand_path "../namespace.h", __FILE__
 File.open path, "wb" do |f|
-  version = Rubinius::ToolSet.current::TS::Melbourne::VERSION
+  version = Rubinius::ToolSets.current::ToolSet::Melbourne::VERSION
 
   if ENV["MELBOURNE_SPEC_VERSION"]
     # Alter the version to not match any possible loaded version

data/ext/rubinius/melbourne/grammar.cpp

@@ -11518,8 +11518,6 @@ static const struct {
 } op_tbl[] = {
   {tDOT2,	  ".."},
   {tDOT3,	  "..."},
-  {'+',	    "+(binary)"},
-  {'-',	    "-(binary)"},
   {tPOW,	  "**"},
   {tUPLUS,	"+@"},
   {tUMINUS,	"-@"},
@@ -11542,6 +11540,8 @@ static const struct {
   {'%',     "%"},
   {'&',     "&"},
   {'*',     "*"},
+  {'+',     "+"},
+  {'-',     "-"},
   {'/',     "/"},
   {'<',     "<"},
   {'>',     ">"},

data/ext/rubinius/melbourne/grammar.y

@@ -6124,8 +6124,6 @@ static const struct {
 } op_tbl[] = {
   {tDOT2,	  ".."},
   {tDOT3,	  "..."},
-  {'+',	    "+(binary)"},
-  {'-',	    "-(binary)"},
   {tPOW,	  "**"},
   {tUPLUS,	"+@"},
   {tUMINUS,	"-@"},
@@ -6148,6 +6146,8 @@ static const struct {
   {'%',     "%"},
   {'&',     "&"},
   {'*',     "*"},
+  {'+',     "+"},
+  {'-',     "-"},
   {'/',     "/"},
   {'<',     "<"},
   {'>',     ">"},

data/ext/rubinius/melbourne/melbourne.cpp

@@ -32,7 +32,7 @@ VALUE MELBOURNE_FILE_TO_AST(VALUE self, VALUE fname, VALUE start) {
 }
 
 void Init_melbourne(void) {
-  VALUE rb_cMelbourne, rb_mToolSet, rb_mTScurrent, rb_mTS;
+  VALUE rb_cMelbourne, rb_mToolSets, rb_mToolSet;
 
   MELBOURNE::init_symbols();
 
@@ -40,10 +40,9 @@ void Init_melbourne(void) {
   VALUE rb_mRubinius = rb_const_get(rb_cObject, rb_intern("Rubinius"));
 #endif
 
-  rb_mToolSet = rb_const_get(rb_mRubinius, rb_intern("ToolSet"));
-  rb_mTScurrent = rb_funcall(rb_mToolSet, rb_intern("current"), 0);
-  rb_mTS = rb_define_module_under(rb_mTScurrent, "TS");
-  rb_cMelbourne = rb_define_class_under(rb_mTS, "Melbourne", rb_cObject);
+  rb_mToolSets = rb_const_get(rb_mRubinius, rb_intern("ToolSets"));
+  rb_mToolSet = rb_funcall(rb_mToolSets, rb_intern("current"), 0);
+  rb_cMelbourne = rb_define_class_under(rb_mToolSet, "Melbourne", rb_cObject);
   rb_define_method(rb_cMelbourne, "string_to_ast",
       RUBY_METHOD_FUNC(MELBOURNE_STRING_TO_AST), 3);
   rb_define_method(rb_cMelbourne, "file_to_ast",

data/lib/rubinius/melbourne/version.rb

@@ -1,5 +1,5 @@
-module Rubinius::ToolSet.current::TS
+module Rubinius::ToolSets.current::ToolSet
   class Melbourne
-    VERSION = "2.0.1.0"
+    VERSION = "2.1.0.0"
   end
 end

data/lib/rubinius/melbourne.rb

@@ -1,27 +1,7 @@
 require "rubinius/melbourne/melbourne"
 require "rubinius/melbourne/version"
 
-class String
-  def to_ast(name="(eval)", line=1)
-    Rubinius::ToolSet.get(:runtime)::Melbourne.parse_string self, name, line
-  end
-
-  def to_sexp(name="(eval)", line=1)
-    to_ast(name, line).to_sexp
-  end
-end
-
-class File
-  def self.to_ast(name, line=1)
-    Rubinius::ToolSet.get(:runtime)::Melbourne.parse_file name, line
-  end
-
-  def self.to_sexp(name, line=1)
-    to_ast(name, line).to_sexp
-  end
-end
-
-module Rubinius::ToolSet.current::TS
+module Rubinius::ToolSets.current::ToolSet
   class Melbourne
     attr_accessor :transforms
     attr_accessor :magic_handler

data/rubinius-melbourne.gemspec

@@ -16,11 +16,14 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.name          = "rubinius-melbourne"
   spec.require_paths = ["lib"]
-  spec.version       = Rubinius::ToolSet.current::TS::Melbourne::VERSION
+  spec.version       = Rubinius::ToolSets.current::ToolSet::Melbourne::VERSION
 
-  spec.add_runtime_dependency     "rubinius-toolset"
+  spec.add_runtime_dependency     "rubinius-toolset", "~> 2.2"
 
-  spec.add_development_dependency "rubinius-toolset", "~> 2.0"
+  spec.add_development_dependency "rubinius-processor", "~> 2.0"
+  spec.add_development_dependency "rubinius-compiler", "~> 2.0"
+  spec.add_development_dependency "rubinius-ast", "~> 2.0"
+  spec.add_development_dependency "rubinius-bridge", "~> 1.0"
   spec.add_development_dependency "redcard", "~> 1.0"
   spec.add_development_dependency "mspec", "~> 1.5"
   spec.add_development_dependency "rake",  "~> 10.0"

data/spec/alias_spec.rb

@@ -1,40 +1,35 @@
 describe "An Alias node" do
-  relates <<-ruby do
+  parse <<-ruby do
       class X
         alias :y :x
       end
     ruby
 
-    parse do
-      [:class, :X, nil, [:scope, [:alias, [:lit, :y], [:lit, :x]]]]
-    end
+    [:class, :X, nil, [:scope, [:block, [:alias, [:lit, :y], [:lit, :x]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       class X
         alias y x
       end
     ruby
 
-    parse do
-      [:class, :X, nil, [:scope, [:alias, [:lit, :y], [:lit, :x]]]]
-    end
+    [:class, :X, nil, [:scope, [:block, [:alias, [:lit, :y], [:lit, :x]]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       class X
         alias :"y\#{1}" :"x\#{2}"
       end
     ruby
 
-    parse do
-      [:class,
-       :X,
-       nil,
-       [:scope,
-        [:alias,
-         [:dsym, "y", [:evstr, [:lit, 1]]],
-         [:dsym, "x", [:evstr, [:lit, 2]]]]]]
-    end
+    [:class,
+     :X,
+     nil,
+     [:scope,
+      [:block,
+       [:alias,
+        [:dsym, "y", [:evstr, [:lit, 1]]],
+        [:dsym, "x", [:evstr, [:lit, 2]]]]]]]
   end
 end

data/spec/and_spec.rb

@@ -1,19 +1,13 @@
 describe "An And node" do
-  relates "(a and b)" do
-    parse do
-      [:and, [:call, nil, :a, [:arglist]], [:call, nil, :b, [:arglist]]]
-    end
+  parse "(a and b)" do
+    [:and, [:call, nil, :a, [:arglist]], [:call, nil, :b, [:arglist]]]
   end
 
-  relates "() and a" do
-    parse do
-      [:and, [:nil], [:call, nil, :a, [:arglist]]]
-    end
+  parse "() and a" do
+    [:and, [:nil], [:call, nil, :a, [:arglist]]]
   end
 
-  relates "a and ()" do
-    parse do
-      [:and, [:call, nil, :a, [:arglist]], [:nil]]
-    end
+  parse "a and ()" do
+    [:and, [:call, nil, :a, [:arglist]], [:nil]]
   end
 end

data/spec/array_spec.rb

@@ -1,81 +1,55 @@
 describe "An Array node" do
-  relates '[1, :b, "c"]' do
-    parse do
-      [:array, [:lit, 1], [:lit, :b], [:str, "c"]]
-    end
+  parse '[1, :b, "c"]' do
+    [:array, [:lit, 1], [:lit, :b], [:str, "c"]]
   end
 
-  relates "%w[a b c]" do
-    parse do
-      [:array, [:str, "a"], [:str, "b"], [:str, "c"]]
-    end
+  parse "%w[a b c]" do
+    [:array, [:str, "a"], [:str, "b"], [:str, "c"]]
   end
 
-  relates '%w[a #{@b} c]' do
-    parse do
-      [:array, [:str, "a"], [:str, "\#{@b}"], [:str, "c"]]
-    end
+  parse '%w[a #{@b} c]' do
+    [:array, [:str, "a"], [:str, "\#{@b}"], [:str, "c"]]
   end
 
-  relates "%W[a b c]" do
-    parse do
-      [:array,
-        [:str, "a"], [:str, "b"], [:str, "c"]]
-    end
+  parse "%W[a b c]" do
+    [:array,
+      [:str, "a"], [:str, "b"], [:str, "c"]]
   end
 
-  relates '%W[a #{@b} c]' do
-    parse do
-      [:array,
-        [:str, "a"],
-        [:dstr, "", [:evstr, [:ivar, :@b]]],
-        [:str, "c"]]
-    end
+  parse '%W[a #{@b} c]' do
+    [:array,
+      [:str, "a"],
+      [:dstr, "", [:evstr, [:ivar, :@b]]],
+      [:str, "c"]]
   end
 
-  relates "[*[1]]" do
-    parse do
-      [:array, [:splat, [:array, [:lit, 1]]]]
-    end
+  parse "[*[1]]" do
+    [:splat, [:array, [:lit, 1]]]
   end
 
-  relates "[*1]" do
-    parse do
-      [:array, [:splat, [:lit, 1]]]
-    end
+  parse "[*1]" do
+    [:splat, [:lit, 1]]
   end
 
-  relates "[[*1]]" do
-    parse do
-      [:array, [:array, [:splat, [:lit, 1]]]]
-    end
+  parse "[[*1]]" do
+    [:array, [:splat, [:lit, 1]]]
   end
 
-  relates "[1, *2]" do
-    parse do
-      [:array, [:lit, 1], [:splat, [:lit, 2]]]
-    end
+  parse "[1, *2]" do
+    [:argscat, [:array, [:lit, 1]], [:lit, 2]]
   end
 
-  relates "[1, *c()]" do
-    parse do
-      [:array, [:lit, 1], [:splat, [:call, nil, :c, [:arglist]]]]
-    end
-
-    # TODO
+  parse "[1, *c()]" do
+    [:argscat, [:array, [:lit, 1]], [:call, nil, :c, [:arglist]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       x = [2]
       [1, *x]
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :x, [:array, [:lit, 2]]],
-       [:array, [:lit, 1], [:splat, [:lvar, :x]]]]
-    end
-
-    # TODO
+    [:block,
+     [:lasgn, :x, [:array, [:lit, 2]]],
+     [:argscat, [:array, [:lit, 1]], [:lvar, :x]]]
   end
 end

data/spec/attrasgn_spec.rb

@@ -1,112 +1,87 @@
 describe "An Attrasgn node" do
-  relates <<-ruby do
+  parse <<-ruby do
       y = 0
       42.method = y
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :y, [:lit, 0]],
-       [:attrasgn, [:lit, 42], :method=, [:arglist, [:lvar, :y]]]]
-    end
+    [:block,
+     [:lasgn, :y, [:lit, 0]],
+     [:attrasgn, [:lit, 42], :method=, [:arglist, [:lvar, :y]]]]
   end
 
-  relates "a.m = *[1]" do
-    parse do
-      [:attrasgn,
-       [:call, nil, :a, [:arglist]],
-       :m=,
-       [:arglist, [:svalue, [:splat, [:array, [:lit, 1]]]]]]
-    end
-
-    # attrasgn_splat
+  parse "a.m = *[1]" do
+    [:attrasgn,
+     [:call, nil, :a, [:arglist]],
+     :m=,
+     [:arglist, [:splat, [:array, [:lit, 1]]]]]
   end
 
-  relates "a[*b] = c" do
-    parse do
-      [:attrasgn,
-       [:call, nil, :a, [:arglist]],
-       :[]=,
-       [:arglist,
-        [:splat, [:call, nil, :b, [:arglist]]],
-        [:call, nil, :c, [:arglist]]]]
-    end
+  parse "a[*b] = c" do
+    [:attrasgn,
+     [:call, nil, :a, [:arglist]],
+     :[]=,
+     [:arglist,
+      [:splat, [:call, nil, :b, [:arglist]]],
+      [:call, nil, :c, [:arglist]]]]
   end
 
-  relates "a[b, *c] = d" do
-    parse do
-      [:attrasgn,
-       [:call, nil, :a, [:arglist]],
-       :[]=,
-       [:arglist,
-        [:array,
-         [:call, nil, :b, [:arglist]],
-         [:splat, [:call, nil, :c, [:arglist]]]],
-        [:call, nil, :d, [:arglist]]]]
-    end
+  parse "a[b, *c] = d" do
+    [:attrasgn,
+     [:call, nil, :a, [:arglist]],
+     :[]=,
+     [:arglist,
+      [:argscat,
+       [:array, [:call, nil, :b, [:arglist]]],
+       [:call, nil, :c, [:arglist]]],
+      [:call, nil, :d, [:arglist]]]]
   end
 
-  relates "a[b, *c] = *d" do
-    parse do
-      [:attrasgn,
-       [:call, nil, :a, [:arglist]],
-       :[]=,
-       [:arglist,
-        [:array,
-         [:call, nil, :b, [:arglist]],
-         [:splat, [:call, nil, :c, [:arglist]]]],
-        [:svalue, [:splat, [:call, nil, :d, [:arglist]]]]]]
-    end
+  parse "a[b, *c] = *d" do
+    [:attrasgn,
+     [:call, nil, :a, [:arglist]],
+     :[]=,
+     [:arglist,
+      [:argscat,
+       [:array, [:call, nil, :b, [:arglist]]],
+       [:call, nil, :c, [:arglist]]],
+      [:splat, [:call, nil, :d, [:arglist]]]]]
   end
 
-  relates "a[b, *c] = d, e" do
-    parse do
-      [:attrasgn,
-       [:call, nil, :a, [:arglist]],
-       :[]=,
-       [:arglist,
-        [:array,
-         [:call, nil, :b, [:arglist]],
-         [:splat, [:call, nil, :c, [:arglist]]]],
-        [:svalue,
-         [:array, [:call, nil, :d, [:arglist]], [:call, nil, :e, [:arglist]]]]]]
-    end
+  parse "a[b, *c] = d, e" do
+    [:attrasgn,
+     [:call, nil, :a, [:arglist]],
+     :[]=,
+     [:arglist,
+      [:argscat,
+       [:array, [:call, nil, :b, [:arglist]]],
+       [:call, nil, :c, [:arglist]]],
+      [:array, [:call, nil, :d, [:arglist]], [:call, nil, :e, [:arglist]]]]]
   end
 
-  relates "a[42] = 24" do
-    parse do
-      [:attrasgn,
-       [:call, nil, :a, [:arglist]],
-       :[]=,
-       [:arglist, [:lit, 42], [:lit, 24]]]
-    end
+  parse "a[42] = 24" do
+    [:attrasgn,
+     [:call, nil, :a, [:arglist]],
+     :[]=,
+     [:arglist, [:lit, 42], [:lit, 24]]]
   end
 
-  relates "self[index, 0] = other_string" do
-    parse do
-      [:attrasgn,
-       [:self],
-       :[]=,
-       [:arglist,
-        [:call, nil, :index, [:arglist]],
-        [:lit, 0],
-        [:call, nil, :other_string, [:arglist]]]]
-    end
+  parse "self[index, 0] = other_string" do
+    [:attrasgn,
+     nil,
+     :[]=,
+     [:arglist,
+      [:call, nil, :index, [:arglist]],
+      [:lit, 0],
+      [:call, nil, :other_string, [:arglist]]]]
   end
 
-  relates <<-ruby do
+  parse <<-ruby do
       a = []
       a [42] = 24
     ruby
 
-    parse do
-      [:block,
-       [:lasgn, :a, [:array]],
-       [:attrasgn, [:lvar, :a], :[]=, [:arglist, [:lit, 42], [:lit, 24]]]]
-    end
-  end
-
-  relates "m { |a.b| }" do
-    # TODO
+    [:block,
+     [:lasgn, :a, [:array]],
+     [:attrasgn, [:lvar, :a], :[]=, [:arglist, [:lit, 42], [:lit, 24]]]]
   end
 end