rubinius-melbourne 2.3.1.0 → 3.0

data/.gitignore

@@ -1,24 +0,0 @@
-*.o
-*.bundle
-*.so
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-.rbx
-Makefile
-namespace.h
-.spec_ruby_version

data/.travis.yml

@@ -1,7 +0,0 @@
-language: ruby
-env:
-  - MELBOURNE_SPEC_VERSION=1 RUBYLIB=lib:.
-before_install: gem install rubinius-toolset
-rvm:
-  - 2.1.0
-  - rbx-2

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in rubinius-melbourne.gemspec
-gemspec

data/LICENSE

@@ -1,25 +0,0 @@
-Copyright (c) 2013, Brian Shirai
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-3. Neither the name of the library nor the names of its contributors may be
-   used to endorse or promote products derived from this software without
-   specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY DIRECT,
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
-OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -1,29 +0,0 @@
-# Rubinius::Melbourne
-
-TODO: Write a gem description
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'rubinius-melbourne'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install rubinius-melbourne
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request

data/Rakefile

@@ -1,46 +0,0 @@
-#!/usr/bin/env rake
-require "bundler/gem_tasks"
-
-def extension_dir
-  Dir.chdir "ext/rubinius/melbourne" do
-    yield
-  end
-end
-
-def spec_ruby_version
-  ".spec_ruby_version"
-end
-
-desc "Generate the parser"
-task :generate do
-  extension_dir { sh "bison -o grammar.cpp grammar.y" }
-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" if File.exist? "Makefile"
-        File.open(spec_ruby_version, "w") { |f| f.write RUBY_DESCRIPTION }
-      end
-    end
-  end
-
-  desc "Build the parser extension"
-  task :build => :generate do
-    extension_dir do
-      ruby "-v extconf.rb"
-      ruby "-e 'system %[make && make install]'"
-    end
-  end
-end
-
-desc "Run the specs"
-task :spec => %w[spec:clean spec:build] do
-  ENV['RUBYLIB'] ||= "#{File.join(__dir__, 'lib')}:#{__dir__}"
-  sh "mspec -r spec/spec_helper spec"
-end
-
-task :default => :spec

data/rubinius-melbourne.gemspec

@@ -1,29 +0,0 @@
-# -*- encoding: utf-8 -*-
-require './lib/rubinius/melbourne/version'
-
-Gem::Specification.new do |spec|
-  spec.authors       = ["Brian Shirai"]
-  spec.email         = ["brixen@gmail.com"]
-  spec.description   = %q{Ruby parser extracted from MRI.}
-  spec.summary       = %q{Rubinius Ruby Parser.}
-  spec.homepage      = "https://github.com/rubinius/rubinius-melbourne"
-  spec.license       = "BSD"
-
-  spec.files         = `git ls-files`.split($\)
-  spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  spec.extensions    = ["ext/rubinius/melbourne/extconf.rb"]
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.name          = "rubinius-melbourne"
-  spec.require_paths = ["lib"]
-  spec.version       = CodeTools::Melbourne::VERSION
-
-  spec.required_ruby_version = ">= 1.9.2"
-
-  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"
-end

data/spec/alias_spec.rb

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

data/spec/and_spec.rb

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

data/spec/array_spec.rb

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

data/spec/attrasgn_spec.rb

@@ -1,91 +0,0 @@
-describe "An Attrasgn node" do
-  parse <<-ruby do
-      y = 0
-      42.method = y
-    ruby
-
-    [:block,
-     [:lasgn, :y, [:lit, 0]],
-     [:attrasgn, [:lit, 42], :method=, [:arglist, [:lvar, :y]]]]
-  end
-
-  parse "a.m = *[1]" do
-    [:attrasgn,
-     [:call, nil, :a, [:arglist]],
-     :m=,
-     [:arglist, [:splat, [:array, [:lit, 1]]]]]
-  end
-
-  parse "a[*b] = c" do
-    [:attrasgn,
-     [:call, nil, :a, [:arglist]],
-     :[]=,
-     [:arglist,
-      [:argspush,
-       [:splat, [:call, nil, :b, [:arglist]]],
-       [:call, nil, :c, [:arglist]]]]]
-  end
-
-  parse "a[b, *c] = d" do
-    [:attrasgn,
-     [:call, nil, :a, [:arglist]],
-     :[]=,
-     [:arglist,
-      [:argspush,
-       [:argscat,
-        [:array, [:call, nil, :b, [:arglist]]],
-        [:call, nil, :c, [:arglist]]],
-       [:call, nil, :d, [:arglist]]]]]
-  end
-
-  parse "a[b, *c] = *d" do
-    [:attrasgn,
-     [:call, nil, :a, [:arglist]],
-     :[]=,
-     [:arglist,
-      [:argspush,
-       [:argscat,
-        [:array, [:call, nil, :b, [:arglist]]],
-        [:call, nil, :c, [:arglist]]],
-       [:splat, [:call, nil, :d, [:arglist]]]]]]
-  end
-
-  parse "a[b, *c] = d, e" do
-    [:attrasgn,
-     [:call, nil, :a, [:arglist]],
-     :[]=,
-     [:arglist,
-      [:argspush,
-       [:argscat,
-        [:array, [:call, nil, :b, [:arglist]]],
-        [:call, nil, :c, [:arglist]]],
-       [:array, [:call, nil, :d, [:arglist]], [:call, nil, :e, [:arglist]]]]]]
-  end
-
-  parse "a[42] = 24" do
-    [:attrasgn,
-     [:call, nil, :a, [:arglist]],
-     :[]=,
-     [:arglist, [:lit, 42], [:lit, 24]]]
-  end
-
-  parse "self[index, 0] = other_string" do
-    [:attrasgn,
-     nil,
-     :[]=,
-     [:arglist,
-      [:call, nil, :index, [:arglist]],
-      [:lit, 0],
-      [:call, nil, :other_string, [:arglist]]]]
-  end
-
-  parse <<-ruby do
-      a = []
-      a [42] = 24
-    ruby
-
-    [:block,
-     [:lasgn, :a, [:array]],
-     [:attrasgn, [:lvar, :a], :[]=, [:arglist, [:lit, 42], [:lit, 24]]]]
-  end
-end

data/spec/back_ref_spec.rb

@@ -1,9 +0,0 @@
-describe "An Back_ref node" do
-  parse "[$&, $`, $', $+]" do
-    [:array,
-     [:back_ref, :&],
-     [:back_ref, :`],
-     [:back_ref, :"'"],
-     [:back_ref, :+]]
-  end
-end

data/spec/call_spec.rb

@@ -1,210 +0,0 @@
-describe "A Call node" do
-  parse "self.method" do
-    [:call, [:self], :method, [:arglist]]
-  end
-
-  parse "1.m(2)" do
-    [:call, [:lit, 1], :m, [:arglist, [:lit, 2]]]
-  end
-
-  parse "h(1, 2, *a)" do
-    [:call, nil, :h,
-     [:arglist,
-       [:lit, 1],
-       [:lit, 2],
-       [:splat, [:call, nil, :a, [:arglist]]]]]
-  end
-
-  parse <<-ruby do
-      begin
-        (1 + 1)
-      end
-    ruby
-
-    [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]]
-  end
-
-  parse "blah(*a)" do
-    [:call, nil, :blah,
-      [:arglist, [:splat, [:call, nil, :a, [:arglist]]]]]
-  end
-
-  parse "a.b(&c)" do
-    [:call,
-     [:call, nil, :a, [:arglist]],
-     :b,
-     [:arglist, [:block_pass, [:call, nil, :c, [:arglist]]]]]
-  end
-
-  parse "a.b(4, &c)" do
-    [:call,
-     [:call, nil, :a, [:arglist]],
-     :b,
-     [:arglist, [:lit, 4], [:block_pass, [:call, nil, :c, [:arglist]]]]]
-  end
-
-  parse "a.b(1, 2, 3, &c)" do
-    [:call,
-     [:call, nil, :a, [:arglist]],
-     :b,
-     [:arglist,
-      [:lit, 1],
-      [:lit, 2],
-      [:lit, 3],
-      [:block_pass, [:call, nil, :c, [:arglist]]]]]
-  end
-
-  parse "a(&b)" do
-    [:call,
-     nil,
-     :a,
-     [:arglist, [:block_pass, [:call, nil, :b, [:arglist]]]]]
-  end
-
-  parse "a(4, &b)" do
-    [:call,
-     nil,
-     :a,
-     [:arglist, [:lit, 4], [:block_pass, [:call, nil, :b, [:arglist]]]]]
-  end
-
-  parse "a(1, 2, 3, &b)" do
-    [:call,
-     nil,
-     :a,
-     [:arglist,
-      [:lit, 1],
-      [:lit, 2],
-      [:lit, 3],
-      [:block_pass, [:call, nil, :b, [:arglist]]]]]
-  end
-
-  parse "define_attr_method(:x, :sequence_name, &Proc.new { |*args| nil })" do
-    [:call,
-     nil,
-     :define_attr_method,
-     [:arglist,
-      [:lit, :x],
-      [:lit, :sequence_name],
-      [:block_pass,
-       [:call,
-        [:const, :Proc],
-        :new,
-        [:arglist, [:iter, [:args, :"*args"], [:nil]]]]]]]
-  end
-
-  parse "r.read_body(dest, &block)" do
-    [:call,
-     [:call, nil, :r, [:arglist]],
-     :read_body,
-     [:arglist,
-      [:call, nil, :dest, [:arglist]],
-      [:block_pass, [:call, nil, :block, [:arglist]]]]]
-  end
-
-  parse "o.m(:a => 1, :b => 2)" do
-    [:call,
-     [:call, nil, :o, [:arglist]],
-     :m,
-     [:arglist, [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]]]
-  end
-
-  parse "o.m(42, :a => 1, :b => 2)" do
-    [:call,
-     [:call, nil, :o, [:arglist]],
-     :m,
-     [:arglist,
-      [:lit, 42],
-      [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]]]
-  end
-
-  parse "o.puts(42)" do
-    [:call, [:call, nil, :o, [:arglist]], :puts, [:arglist, [:lit, 42]]]
-  end
-
-  parse "1.b(c)" do
-    [:call, [:lit, 1], :b, [:arglist, [:call, nil, :c, [:arglist]]]]
-  end
-
-  parse "(v = (1 + 1)).zero?" do
-    [:call,
-     [:lasgn, :v, [:call, [:lit, 1], :+, [:arglist, [:lit, 1]]]],
-     :zero?,
-     [:arglist]]
-  end
-
-  parse "-2**31" do
-    [:call,
-     [:call, [:lit, 2], :**, [:arglist, [:lit, 31]]],
-     :-@,
-     [:arglist]]
-  end
-
-  parse "a[]" do
-    [:call, [:call, nil, :a, [:arglist]], :[], [:arglist]]
-  end
-
-  parse "m(:a => 1, :b => 2)" do
-    [:call,
-     nil,
-     :m,
-     [:arglist, [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]]]
-  end
-
-  parse "m(42, :a => 1, :b => 2)" do
-    [:call,
-     nil,
-     :m,
-     [:arglist, [:lit, 42], [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]]]
-  end
-
-  parse "m(42)" do
-    [:call, nil, :m, [:arglist, [:lit, 42]]]
-  end
-
-  parse "a(:b) { :c }" do
-    [:call, nil, :a, [:arglist, [:lit, :b], [:iter, [:args], [:lit, :c]]]]
-  end
-
-  parse "a [42]" do
-    [:call, nil, :a, [:arglist, [:array, [:lit, 42]]]]
-  end
-
-  parse "42 if block_given?" do
-    [:if, [:call, nil, :block_given?, [:arglist]], [:lit, 42], nil]
-  end
-
-  parse "method" do
-    [:call, nil, :method, [:arglist]]
-  end
-
-  parse <<-ruby do
-      a << begin
-             b
-           rescue
-             c
-           end
-    ruby
-
-    [:call,
-     [:call, nil, :a, [:arglist]],
-     :<<,
-     [:arglist,
-      [:rescue,
-       [:call, nil, :b, [:arglist]],
-       [:resbody,
-        [:array, [:const, :StandardError]],
-        [:call, nil, :c, [:arglist]]]]]]
-  end
-
-  parse "meth([*[1]])" do
-    [:call,
-      nil,
-      :meth,
-      [:arglist, [:splat, [:array, [:lit, 1]]]]]
-  end
-
-  parse "meth(*[1])" do
-    [:call, nil, :meth, [:arglist, [:splat, [:array, [:lit, 1]]]]]
-  end
-end