opal 0.10.0 → 0.11.0

data/spec/lib/compiler/pre_processed_conditionals_spec.rb

@@ -1,87 +0,0 @@
-require 'lib/spec_helper'
-
-describe Opal::Compiler do
-  def expect_compiled(*args)
-    expect(Opal::Compiler.new(*args).compile)
-  end
-
-  describe "pre-processed if conditions" do
-    it "compiles if blocks using RUBY_ENGINE/RUBY_PLATFORM == opal" do
-      expect_compiled(<<-RUBY).to include("should_compile_fine")
-      if RUBY_ENGINE == 'opal'
-        :should_compile_fine
-      end
-      RUBY
-
-      expect_compiled(<<-RUBY).to include("so_should_this")
-      if RUBY_PLATFORM == 'opal'
-        :so_should_this
-      end
-      RUBY
-    end
-
-    it "does not compile if blocks using RUBY_ENGINE/RUBY_PLATFORM != opal" do
-      expect_compiled(<<-RUBY).to_not include('should_not_compile')
-        if RUBY_ENGINE != 'opal'
-          :should_not_compile
-        end
-      RUBY
-
-      expect_compiled(<<-RUBY).to_not include('should_not_compile')
-        if RUBY_PLATFORM != 'opal'
-          :should_not_compile
-        end
-      RUBY
-    end
-
-    it "skips elsif/else parts for CONST == opal" do
-      expect_compiled(<<-RUBY).to_not include("should_be_skipped")
-      if RUBY_PLATFORM == "opal"
-        :ok
-      else
-        :should_be_skipped
-      end
-      RUBY
-
-      result = expect_compiled(<<-RUBY)
-      if RUBY_ENGINE == 'opal'
-        :this_compiles
-      elsif false
-        :this_does_not_compile
-      else
-        :this_neither
-      end
-      RUBY
-
-      result.to_not include("this_does_not_compile", "this_neither")
-    end
-
-    it "generates if-code as normal without check" do
-      expect_compiled(<<-RUBY).to include("should_compile", "and_this")
-      if some_conditional
-        :should_compile
-      else
-        :and_this
-      end
-      RUBY
-    end
-  end
-
-  describe "pre-processed unless conditionals" do
-    it "skips over if using RUBY_ENGINE/RUBY_PLATFORM == 'opal'" do
-      expect_compiled(<<-RUBY).to_not include("should_not_compile")
-      unless RUBY_ENGINE == 'opal'
-        :should_not_compile
-      end
-      RUBY
-    end
-
-    it "generates unless code as normal if no check" do
-      expect_compiled(<<-RUBY).to include("this_should_compile")
-      unless this_is_true
-        :this_should_compile
-      end
-      RUBY
-    end
-  end
-end

data/spec/lib/compiler_spec.rb

@@ -1,285 +0,0 @@
-require 'lib/spec_helper'
-require 'support/match_helpers'
-
-describe Opal::Compiler do
-  describe 'requiring' do
-    it 'calls #require' do
-      expect_compiled("require 'pippo'").to include('self.$require("pippo")')
-    end
-  end
-
-  describe 'requirable' do
-    it 'executes the file' do
-      expect_compiled("").to include('(function(Opal) {')
-      expect_compiled("").to end_with("})(Opal);\n")
-    end
-
-    it 'puts the compiled into "Opal.modules"' do
-      options = { :requirable => true, :file => "pippo" }
-      expect_compiled("", options).to include('Opal.modules["pippo"] = function(Opal) {')
-      expect_compiled("", options).to end_with("};\n")
-    end
-  end
-
-  it 'raises syntax errors properly' do
-    expect(lambda {Opal::Compiler.new('def foo').compile}).to raise_error SyntaxError, /An error occurred while compiling:.*false/m
-  end
-
-  it "should compile simple ruby values" do
-    expect_compiled("3.142").to include("return 3.142")
-    expect_compiled("123e1").to include("return 1230")
-    expect_compiled("123E+10").to include("return 1230000000000")
-    expect_compiled("false").to include("return false")
-    expect_compiled("true").to include("return true")
-    expect_compiled("nil").to include("return nil")
-  end
-
-  it "should compile ruby strings" do
-    expect_compiled('"hello world"').to include('return "hello world"')
-    expect_compiled('"hello #{100}"').to include('"hello "', '100')
-  end
-
-  it "should compile method calls" do
-    expect_compiled("self.inspect").to include("$inspect()")
-    expect_compiled("self.map { |a| a + 10 }").to include("$map")
-  end
-
-  it "adds method missing stubs" do
-    expect_compiled("self.puts 'hello'").to include("Opal.add_stubs(['$puts'])")
-  end
-
-  it 'adds method missing stubs with operators' do
-    expect_compiled("class Foo; end; Foo.new > 5").to include("Opal.add_stubs(['$>', '$new'])")
-  end
-
-  it "should compile constant lookups" do
-    expect_compiled("Object").to include("Object")
-    expect_compiled("Array").to include("Array")
-  end
-
-  it "should compile undef calls" do
-    expect_compiled("undef a").to include("Opal.udef(self, '$a')")
-    expect_compiled("undef a,b").to match(/Opal.udef\(self, '\$a'\);.*return Opal.udef\(self, '\$b'\);/m)
-  end
-
-  describe "class names" do
-    it "generates a named function for class using $ prefix" do
-      expect_compiled("class Foo; end").to include("function $Foo")
-    end
-  end
-
-  describe "method names" do
-    it "generates a named function for method" do
-      expect_compiled("def test_method; end").to include("function ːtest_method()")
-    end
-
-    context "when function name is reserved" do
-      it "generates a valid named function for method" do
-        expect_compiled("def Array; end").to include("function ːArray()")
-      end
-    end
-
-    context "when function name is not valid" do
-      it "skips generating a name" do
-        expect_compiled("def test_method?; end").to include("function()")
-      end
-    end
-  end
-
-  describe "debugger special method" do
-    it "generates debugger keyword in javascript" do
-      expect_compiled("debugger").to include("debugger")
-      expect_compiled("debugger").to_not include("$debugger")
-    end
-  end
-
-  describe "DATA special variable" do
-    it "is not a special case unless __END__ part present in source" do
-      expect_compiled("DATA").to include("DATA")
-      expect_compiled("DATA\n__END__").to_not include("DATA")
-    end
-
-    it "DATA gets compiled as a reference to special $__END__ variable" do
-      expect_compiled("a = DATA\n__END__").to include("a = $__END__")
-    end
-
-    it "causes the compiler to create a reference to special __END__ variable" do
-      expect_compiled("DATA\n__END__\nFord Perfect").to include("$__END__ = ")
-    end
-
-    it "does not create a reference to __END__ vairbale unless __END__ content present" do
-      expect_compiled("DATA").to_not include("$__END__ = ")
-    end
-  end
-
-  describe "escapes in x-strings" do
-    it "compiles the exscapes directly as appearing in x-strings" do
-      expect_compiled('`"hello\nworld"`').to include('"hello\nworld"')
-      expect_compiled('%x{"hello\nworld"}').to include('"hello\nworld"')
-    end
-  end
-
-    describe 'pre-processing require-ish methods' do
-    describe '#require' do
-      it 'parses and resolve #require argument' do
-        compiler = compiler_for(%Q{require "#{__FILE__}"})
-        expect(compiler.requires).to eq([__FILE__])
-      end
-    end
-
-    describe '#autoload' do
-      it 'ignores autoload outside of context class' do
-        compiler = compiler_for(%Q{autoload Whatever, "#{__FILE__}"})
-        expect(compiler.requires).to eq([])
-      end
-
-      it 'parses and resolve second #autoload arguments' do
-        compiler = compiler_for(%Q{class Foo; autoload Whatever, "#{__FILE__}"; end})
-        expect(compiler.requires).to eq([__FILE__])
-      end
-    end
-
-    describe '#require_relative' do
-      it 'parses and resolve #require_relative argument' do
-        compiler = compiler_for(%Q{require_relative "./#{File.basename(__FILE__)}"}, file: __FILE__)
-        expect(compiler.requires).to eq([__FILE__])
-      end
-    end
-
-    describe '#require_tree' do
-      require 'pathname'
-
-      it 'parses and resolve #require argument' do
-        file = Pathname(__FILE__).join('../fixtures/require_tree_test.rb')
-
-        compiler = compiler_for(file.read)
-        expect(compiler.required_trees).to eq(['../fixtures/required_tree_test'])
-      end
-    end
-  end
-
-  describe 'truthy check' do
-    context 'no parentheses' do
-      context 'with operators' do
-        it 'excludes nil check for primitives' do
-          expect_compiled('foo = 42 if 2 > 3').to include('if ($rb_gt(2, 3))')
-          expect_compiled('foo = 42 if 2.5 > 3.5').to include('if ($rb_gt(2.5, 3.5))')
-          expect_compiled('foo = 42 if true > false').to include('if ($rb_gt(true, false))')
-
-          expect_compiled('foo = 42 if 2 == 3').to include("if ((2)['$=='](3))")
-          expect_compiled('foo = 42 if 2.5 == 3.5').to include("if ((2.5)['$=='](3.5))")
-          expect_compiled('foo = 42 if true == false').to include("if (true['$=='](false))")
-        end
-
-        it 'adds nil check for strings' do
-          expect_compiled('foo = 42 if "test" > "bar"').to include('if ((($a = $rb_gt("test", "bar")) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-        end
-
-        it 'specifically == excludes nil check for strings' do
-          expect_compiled('foo = 42 if "test" == "bar"').to include("if (\"test\"['$=='](\"bar\"))")
-        end
-
-        it 'adds nil check for lvars' do
-          expect_compiled("bar = 4\nfoo = 42 if bar > 5").to include('if ((($a = $rb_gt(bar, 5)) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-        end
-
-        it 'specifically == excludes nil check for lvars' do
-          expect_compiled("bar = 4\nfoo = 42 if bar == 5").to include("if (bar['$=='](5))")
-        end
-
-        it 'adds nil check for constants' do
-          expect_compiled("foo = 42 if Test > 4").to include("if ((($a = $rb_gt($scope.get('Test'), 4)) !== nil && $a != null && (!$a.$$is_boolean || $a == true))) ")
-        end
-
-        it 'specifically == excludes nil check for constants' do
-          expect_compiled("foo = 42 if Test == 4").to include("if ($scope.get('Test')['$=='](4))")
-        end
-      end
-
-      context 'without operators' do
-        it 'adds nil check for primitives' do
-          expect_compiled('foo = 42 if 2').to include('if ((($a = 2) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-          expect_compiled('foo = 42 if 2.5').to include('if ((($a = 2.5) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-          expect_compiled('foo = 42 if true').to include('if ((($a = true) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-        end
-
-        it 'adds nil check for boolean method calls' do
-          expect_compiled('foo = 42 if true.something').to include('if ((($a = true.$something()) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-        end
-
-        it 'adds nil check for strings' do
-          expect_compiled('foo = 42 if "test"').to include('if ((($a = "test") !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-        end
-
-        it 'adds nil check for lvars' do
-          expect_compiled("bar = 4\nfoo = 42 if bar").to include('if (bar !== false && bar !== nil && bar != null)')
-        end
-
-        it 'adds nil check for constants' do
-          expect_compiled("foo = 42 if Test").to include("if ((($a = $scope.get('Test')) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))")
-        end
-      end
-    end
-
-    context 'parentheses' do
-      context 'with operators' do
-        it 'adds nil check for primitives' do
-          expect_compiled('foo = 42 if (2 > 3)').to include('if ((($a = ($rb_gt(2, 3))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-          expect_compiled('foo = 42 if (2.5 > 3.5)').to include('if ((($a = ($rb_gt(2.5, 3.5))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-          expect_compiled('foo = 42 if (true > false)').to include('if ((($a = ($rb_gt(true, false))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-
-          expect_compiled('foo = 42 if (2 == 3)').to include("if ((($a = ((2)['$=='](3))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))")
-          expect_compiled('foo = 42 if (2.5 == 3.5)').to include("if ((($a = ((2.5)['$=='](3.5))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))")
-          expect_compiled('foo = 42 if (true == false)').to include("if ((($a = (true['$=='](false))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))")
-        end
-
-        it 'adds nil check for strings' do
-          expect_compiled('foo = 42 if ("test" > "bar")').to include('if ((($a = ($rb_gt("test", "bar"))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-          expect_compiled('foo = 42 if ("test" == "bar")').to include("if ((($a = (\"test\"['$=='](\"bar\"))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))")
-        end
-
-        it 'adds nil check for lvars' do
-          expect_compiled("bar = 4\nfoo = 42 if (bar > 5)").to include('if ((($a = ($rb_gt(bar, 5))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-          expect_compiled("bar = 4\nfoo = 42 if (bar == 5)").to include("if ((($a = (bar['$=='](5))) !== nil && $a != null && (!$a.$$is_boolean || $a == true))) ")
-        end
-
-        it 'adds nil check for constants' do
-          expect_compiled("foo = 42 if (Test > 4)").to include("if ((($a = ($rb_gt($scope.get('Test'), 4))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))")
-          expect_compiled("foo = 42 if (Test == 4)").to include("if ((($a = ($scope.get('Test')['$=='](4))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))")
-        end
-      end
-
-      context 'without operators' do
-        it 'adds nil check for primitives' do
-          expect_compiled('foo = 42 if (2)').to include('if ((($a = (2)) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-          expect_compiled('foo = 42 if (2.5)').to include('if ((($a = (2.5)) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-          expect_compiled('foo = 42 if (true)').to include('if ((($a = (true)) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-        end
-
-        it 'adds nil check for boolean method calls' do
-          expect_compiled('foo = 42 if (true.something)').to include('if ((($a = (true.$something())) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-        end
-
-        it 'adds nil check for strings' do
-          expect_compiled('foo = 42 if ("test")').to include('if ((($a = ("test")) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-        end
-
-        it 'adds nil check for lvars' do
-          expect_compiled("bar = 4\nfoo = 42 if (bar)").to include('if ((($a = (bar)) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))')
-        end
-
-        it 'adds nil check for constants' do
-          expect_compiled("foo = 42 if (Test)").to include("if ((($a = ($scope.get('Test'))) !== nil && $a != null && (!$a.$$is_boolean || $a == true)))")
-        end
-      end
-    end
-  end
-
-  def expect_compiled(*args)
-    expect(Opal::Compiler.new(*args).compile)
-  end
-
-  def compiler_for(*args)
-    Opal::Compiler.new(*args).tap(&:compile)
-  end
-end

data/spec/lib/config_spec.rb

@@ -1,13 +0,0 @@
-require 'lib/spec_helper'
-require 'opal/config'
-
-describe Opal::Config do
-  describe '.default_config' do
-    it 'is new each time' do
-      default_config1 = described_class.default_config
-      default_config2 = described_class.default_config
-      expect(default_config1).to eq(default_config2)
-      expect(default_config1).not_to equal(default_config2)
-    end
-  end
-end

data/spec/lib/dependency_resolver_spec.rb

@@ -1,40 +0,0 @@
-require 'lib/spec_helper'
-
-describe Opal::Nodes::CallNode::DependencyResolver do
-  let(:compiler) { double(:compiler, :dynamic_require_severity => :none) }
-
-  it "resolves simple strings to themselves" do
-    expect(resolve s(:str, 'foo')).to eq('foo')
-  end
-
-  context "using a dynamic segment not supported" do
-    it "raises a compiler error when severity is :error" do
-      compiler = double(:compiler, :dynamic_require_severity => :error)
-      expect(compiler).to receive(:error).once
-      expect(compiler).to receive(:dynamic_require_severity).once
-      described_class.new(compiler, s(:self)).resolve
-    end
-
-    it "produces a compiler warning when severity is :warning" do
-      compiler = double(:compiler, :dynamic_require_severity => :warning)
-      expect(compiler).to receive(:warning).once
-      expect(compiler).to receive(:dynamic_require_severity).once
-      described_class.new(compiler, s(:self)).resolve
-    end
-
-    it "does not produce a warning or error for other options" do
-      compiler = double(:compiler, :dynamic_require_severity => :foo)
-      expect(compiler).to_not receive(:warning)
-      expect(compiler).to_not receive(:error)
-      described_class.new(compiler, s(:self)).resolve
-    end
-  end
-
-  def s(*parts)
-    Opal::Sexp.new(parts)
-  end
-
-  def resolve(sexp)
-    described_class.new(compiler, sexp).resolve
-  end
-end

data/spec/lib/fixtures/complex_sprockets.js.rb.erb

@@ -1,4 +0,0 @@
-#= require no_requires
-//= require jst_file
-#= require_tree ./required_tree_test
-require 'file_with_directives'

data/spec/lib/fixtures/file_with_directives.js

@@ -1,2 +0,0 @@
-//= require required_file
-console.log('file with directives');

data/spec/lib/fixtures/jst_file.js.jst

@@ -1 +0,0 @@
-#= require sprockets_file

data/spec/lib/fixtures/no_requires.rb

@@ -1 +0,0 @@
-puts 'hi there'

data/spec/lib/fixtures/opal_file.rb

@@ -1,2 +0,0 @@
-require 'opal'
-puts 'hi from opal!'

data/spec/lib/fixtures/require_tree_test.rb

@@ -1,3 +0,0 @@
-require_tree '../fixtures/required_tree_test'
-
-puts 5

data/spec/lib/fixtures/required_file.js

@@ -1 +0,0 @@
-console.log('required file');

data/spec/lib/fixtures/required_tree_test/required_file1.rb

@@ -1 +0,0 @@
-p 1

data/spec/lib/fixtures/required_tree_test/required_file2.rb

@@ -1 +0,0 @@
-p 2

data/spec/lib/fixtures/requires.rb

@@ -1,7 +0,0 @@
-require 'foo'
-
-puts 'hello'
-
-require 'bar'
-
-puts 'goodbye'

data/spec/lib/fixtures/source_map/subfolder/other_file.rb

@@ -1 +0,0 @@
-puts 'other!'

data/spec/lib/fixtures/source_map.rb

@@ -1 +0,0 @@
-puts 'smap!'

data/spec/lib/fixtures/sprockets_file.js.rb

@@ -1,3 +0,0 @@
-require 'opal'
-require 'native'
-puts 'sprockets!'

data/spec/lib/fixtures/sprockets_require_tree_test.rb

@@ -1,3 +0,0 @@
-#=require_tree ./required_tree_test
-
-puts 5

data/spec/lib/hike_path_finder_spec.rb

@@ -1,23 +0,0 @@
-require 'lib/spec_helper'
-require 'lib/shared/path_finder_shared'
-require 'opal/hike_path_finder'
-
-describe Opal::HikePathFinder do
-  subject(:path_finder) { described_class.new(root) }
-  let(:root) { File.expand_path('..', __FILE__) }
-  let(:path) { 'fixtures/opal_file' }
-  let(:full_path) { File.join(root, path + ext) }
-  let(:ext) { '.rb' }
-
-  include_examples :path_finder
-
-  context 'with absolute paths' do
-    it 'returns the path if exists' do
-      expect(path_finder.find(full_path)).to eq(full_path)
-    end
-
-    it 'gives nil if it is missing' do
-      expect(path_finder.find(full_path+'/not-real')).to eq(nil)
-    end
-  end
-end

data/spec/lib/lexer_spec.rb

@@ -1,110 +0,0 @@
-require 'support/parser_helpers'
-require 'opal/parser'
-
-describe Opal::Lexer do
-  it "sets correct line information for each token" do
-    expect_lines("42").to eq([1])
-    expect_lines("\n3.142").to eq([2])
-    expect_lines("3.142\n42\n57").to eq([1, 2, 3])
-  end
-
-  it "increments the line count over multiple new lines" do
-    expect_lines("1\n\n\n2").to eq([1, 4])
-    expect_lines("\n\n\n3\n\n5\n\n").to eq([4, 6])
-  end
-
-  it "increments line numbers over =begin...=end blocks" do
-    expect_lines("=begin\n=end\n1").to eq([3])
-    expect_lines("=begin\nfoo\nbar\n=end\n42\n43").to eq([5, 6])
-  end
-
-  it "sets correct column for each token" do
-    expect_columns("1").to eq([0])
-    expect_columns("1;2; 3").to eq([0, 2, 5])
-    expect_columns("    \t3").to eq([5])
-  end
-
-  it "sets the column to 0 on each new line" do
-    expect_columns("1\n2\n\n\n3\n 4").to eq([0, 0, 0, 1])
-  end
-
-  it "sets column with regard to whitespace and other tokens before it" do
-    expect_columns("true;  false;  self\n  ni;").to eq([0, 7, 15, 2])
-  end
-
-  describe "double-quoted strings" do
-    it "escape backslashes in strings" do
-      expect_parsed_string("\"foo\"").to eq("foo")
-      expect_parsed_string("\"foo\\tbar\"").to eq("foo\tbar")
-      expect_parsed_string("\"\\\"foo\"").to eq("\"foo")
-    end
-
-    it "removes new line in string directly after backslash" do
-      expect_parsed_string("\"foo\\\nbar\"").to eq("foobar")
-    end
-  end
-
-  describe "single-quoted strings" do
-    it "do not support interpolation" do
-      expect_parsed_string("'foo\#{self}'").to eq('foo#{self}')
-      expect_parsed_string("'\#@bar'").to eq('#@bar')
-      expect_parsed_string("'\#$baz'").to eq('#$baz')
-    end
-
-    it "do not escape backslashed characters" do
-      expect_parsed_string("'foo'").to eq("foo")
-      expect_parsed_string("'foo\\tbar'").to eq("foo\\tbar")
-    end
-
-    it "can escape \\ and \' characters" do
-      expect_parsed_string("'a\\\\b\\'c'").to eq("a\\b'c")
-    end
-  end
-
-  describe "escaped characters" do
-    it "can parse octal escape sequences" do
-      expect_parsed_string('"\\101\\103\\102"').to eq("ACB")
-    end
-
-    it "can parse hex escape sequences" do
-      expect_parsed_string('"\\x61\\x63\\x62"').to eq('acb')
-    end
-
-    if defined?(::Encoding)
-      it "can parse simple unicode sequences" do
-        expect_parsed_string('"\\u1234"').to eq("\u1234")
-      end
-    end
-  end
-
-  describe "__END__ content in a source file" do
-    it "ignores token and following content if at start of line and followed by newline" do
-      expect_parsed("42\n__END__").to eq([:int, 42])
-      expect_parsed("42\n__END__\nFred").to eq([:int, 42])
-      expect_parsed(" __END__").to eq([:call, nil, :__END__, [:arglist]])
-      expect_parsed("__END__ ").to eq([:call, nil, :__END__, [:arglist]])
-      expect_parsed("__END__ 42").to eq([:call, nil, :__END__, [:arglist, [:int, 42]]])
-    end
-
-    it "adds any __END__ content to lexer.eof_content" do
-      parser = Opal::Parser.new
-      parser.parse("42")
-      expect(parser.lexer.eof_content).to eq(nil)
-
-      parser = Opal::Parser.new
-      parser.parse("42\n__END__\nFord\nPerfect")
-      expect(parser.lexer.eof_content).to eq("Ford\nPerfect")
-
-      parser = Opal::Parser.new
-      parser.parse("42\n__END__\n")
-      expect(parser.lexer.eof_content).to eq("")
-    end
-  end
-
-  describe "variable dereferencing ([])" do
-    it "handles referencing correctly on local variables in scope" do
-      expect_parsed("x = 0; x [0]").to eq([:block, [:lasgn, :x, [:int, 0]],
-       [:call, [:lvar, :x], :[], [:arglist, [:int, 0]]]])
-    end
-  end
-end

data/spec/lib/parser/alias_spec.rb

@@ -1,26 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The alias keyword" do
-  describe "with fitem" do
-    it "should return an s(:alias) with s(:sym)" do
-      parsed("alias a b").should == [:alias, [:sym, :a], [:sym, :b]]
-      parsed("alias == equals").should == [:alias, [:sym, :==], [:sym, :equals]]
-    end
-
-    it "should accept symbols as names" do
-      parsed("alias :foo :bar").should == [:alias, [:sym, :foo], [:sym, :bar]]
-    end
-  end
-
-  describe "with gvar" do
-    it "should return a s(:valias) with two gvars as arguments" do
-      parsed("alias $foo $bar").should == [:valias, :$foo, :$bar]
-    end
-  end
-
-  describe "with gvar and nth ref" do
-    it "should return a s(:valias) with two values as arguments" do
-      parsed("alias $foo $1").should == [:valias, :$foo, :"1"]
-    end
-  end
-end

data/spec/lib/parser/and_spec.rb

@@ -1,13 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The and statement" do
-  it "should always return s(:and)" do
-    parsed("1 and 2").should == [:and, [:int, 1], [:int, 2]]
-  end
-end
-
-describe "The && expression" do
-  it "should always return s(:and)" do
-    parsed("1 && 2").should == [:and, [:int, 1], [:int, 2]]
-  end
-end