opal 0.11.0.rc1 → 0.11.0

data/spec/filters/unsupported/struct.rb

@@ -1,6 +0,0 @@
-opal_unsupported_filter "Struct" do
-  fails "Struct#initialize is private"
-  fails "Struct.new does not create a constant with symbol as first argument"
-  fails "Struct.new fails with invalid constant name as first argument" # this invalid name gets interpreted as a struct member
-  fails "Struct.new raises a TypeError if object is not a Symbol"
-end

data/spec/filters/unsupported/symbol.rb

@@ -1,20 +0,0 @@
-opal_unsupported_filter "Symbol" do
-  fails "Numeric#coerce raises a TypeError when passed a Symbol"
-  fails "Fixnum#coerce raises a TypeError when given an Object that does not respond to #to_f"
-  fails "Symbol#to_proc produces a proc that always returns [[:rest]] for #parameters"
-  fails "The throw keyword does not convert strings to a symbol"
-  fails "Module#const_get raises a NameError if a Symbol has a toplevel scope qualifier"
-  fails "Module#const_get raises a NameError if a Symbol is a scoped constant name"
-  fails "A Symbol literal is a ':' followed by any number of valid characters"
-  fails "A Symbol literal is a ':' followed by a single- or double-quoted string that may contain otherwise invalid characters"
-  fails "A Symbol literal is converted to a literal, unquoted representation if the symbol contains only valid characters"
-  fails "A Symbol literal can be created by the %s-delimited expression"
-  fails "A Symbol literal can contain null in the string"
-  fails "A Symbol literal can be an empty string"
-  fails "Marshal.dump with a Symbol dumps a Symbol"
-  fails "Marshal.dump with a Symbol dumps a big Symbol"
-  fails "Marshal.dump with a Symbol dumps an encoded Symbol"
-  fails "Marshal.dump with a Symbol dumps a binary encoded Symbol"
-  fails "Marshal.dump with an Array dumps a non-empty Array" # this particular spec dumps a Symbol, spec with String instead of Symbol is in spec/opal/
-  fails "Hash literal raises a TypeError if any splatted elements keys are not symbols"
-end

data/spec/filters/unsupported/taint.rb

@@ -1,30 +0,0 @@
-opal_unsupported_filter "taint" do
-  fails "Hash#reject with extra state does not taint the resulting hash"
-  fails "Kernel#inspect returns a tainted string if self is tainted"
-  fails "Module#append_features copies own tainted status to the given module"
-  fails "Module#append_features copies own untrusted status to the given module"
-  fails "Module#extend_object does not copy own tainted status to the given object"
-  fails "Module#extend_object does not copy own untrusted status to the given object"
-  fails "Module#prepend_features copies own tainted status to the given module"
-  fails "Module#prepend_features copies own untrusted status to the given module"
-  fails "String#% doesn't taint the result for %E when argument is tainted"
-  fails "String#% doesn't taint the result for %G when argument is tainted"
-  fails "String#% doesn't taint the result for %e when argument is tainted"
-  fails "String#% doesn't taint the result for %f when argument is tainted"
-  fails "String#% doesn't taint the result for %g when argument is tainted"
-  fails "String#[] with Regexp always taints resulting strings when self or regexp is tainted"
-  fails "String#[] with Regexp returns an untrusted string if the regexp is untrusted"
-  fails "String#byteslice with Range always taints resulting strings when self is tainted"
-  fails "String#byteslice with index, length always taints resulting strings when self is tainted"
-  fails "String#dump taints the result if self is tainted"
-  fails "String#slice with Regexp always taints resulting strings when self or regexp is tainted"
-  fails "String#slice with Regexp returns an untrusted string if the regexp is untrusted"
-  fails "StringScanner#getbyte taints the returned String if the input was tainted"
-  fails "StringScanner#getch taints the returned String if the input was tainted"
-  fails "StringScanner#matched taints the returned String if the input was tainted"
-  fails "StringScanner#peek taints the returned String if the input was tainted"
-  fails "StringScanner#peep taints the returned String if the input was tainted"
-  fails "StringScanner#post_match taints the returned String if the input was tainted"
-  fails "StringScanner#pre_match taints the returned String if the input was tainted"
-  fails "StringScanner#rest taints the returned String if the input was tainted"
-end

data/spec/filters/unsupported/thread.rb

@@ -1,7 +0,0 @@
-opal_unsupported_filter "Thread" do
-  fails "StandardError is a superclass of ThreadError"
-  fails "The throw keyword raises an ArgumentError if used to exit a thread"
-  fails "The throw keyword clears the current exception"
-  fails "Module#autoload loads the registered constant even if the constant was already loaded by another thread"
-  fails "The return keyword in a Thread raises a LocalJumpError if used to exit a thread"
-end

data/spec/filters/unsupported/time.rb

@@ -1,202 +0,0 @@
-opal_unsupported_filter "Time" do
-  fails "Time#+ accepts arguments that can be coerced into Rational"
-  fails "Time#+ adds a negative Float"
-  fails "Time#+ increments the time by the specified amount as rational numbers"
-  fails "Time#+ maintains microseconds precision"
-  fails "Time#+ maintains nanoseconds precision"
-  fails "Time#+ maintains precision"
-  fails "Time#+ maintains subseconds precision"
-  fails "Time#+ returns a time with the same fixed offset as self"
-  fails "Time#+ tracks microseconds"
-  fails "Time#+ tracks nanoseconds"
-  fails "Time#- accepts arguments that can be coerced into Rational"
-  fails "Time#- maintains microseconds precision"
-  fails "Time#- maintains nanoseconds precision"
-  fails "Time#- maintains precision"
-  fails "Time#- maintains subseconds precision"
-  fails "Time#- returns a time with nanoseconds precision between two time objects"
-  fails "Time#- returns a time with the same fixed offset as self"
-  fails "Time#- tracks microseconds"
-  fails "Time#- tracks nanoseconds"
-  fails "Time#<=> returns -1 if the first argument is a fraction of a microsecond before the second argument"
-  fails "Time#<=> returns -1 if the first argument is a point in time before the second argument (down to a microsecond)"
-  fails "Time#<=> returns 0 if time is the same as other, including fractional microseconds"
-  fails "Time#<=> returns 1 if the first argument is a fraction of a microsecond after the second argument"
-  fails "Time#<=> returns 1 if the first argument is a point in time after the second argument (down to a microsecond)"
-  fails "Time#day returns the day of the month (1..n) for a local Time"
-  fails "Time#day returns the day of the month for a Time with a fixed offset"
-  fails "Time#dst? dst? returns whether time is during daylight saving time"
-  fails "Time#dup returns a subclass instance"
-  fails "Time#eql? returns false if self and other have differing fractional microseconds"
-  fails "Time#eql? returns false if self and other have differing numbers of microseconds"
-  fails "Time#getgm returns a new time which is the utc representation of time"
-  fails "Time#getlocal raises ArgumentError if the argument represents a value greater than or equal to 86400 seconds"
-  fails "Time#getlocal raises ArgumentError if the argument represents a value less than or equal to -86400 seconds"
-  fails "Time#getlocal raises ArgumentError if the String argument is not of the form (+|-)HH:MM"
-  fails "Time#getlocal returns a new time which is the local representation of time"
-  fails "Time#getlocal returns a new time with the correct utc_offset according to the set timezone"
-  fails "Time#getlocal returns a Time with a UTC offset of the specified number of Rational seconds"
-  fails "Time#getlocal returns a Time with a UTC offset specified as +HH:MM"
-  fails "Time#getlocal returns a Time with a UTC offset specified as -HH:MM"
-  fails "Time#getlocal returns a Time with UTC offset specified as an Integer number of seconds"
-  fails "Time#getlocal with an argument that responds to #to_int coerces using #to_int"
-  fails "Time#getlocal with an argument that responds to #to_r coerces using #to_r"
-  fails "Time#getlocal with an argument that responds to #to_str coerces using #to_str"
-  fails "Time#getutc returns a new time which is the utc representation of time"
-  fails "Time#gmtime returns the utc representation of time"
-  fails "Time#gmtoff given negative offset returns a negative offset"
-  fails "Time#gmtoff given positive offset returns a positive offset"
-  fails "Time#gmtoff returns offset as Rational"
-  fails "Time#gmtoff returns the correct offset for Hawaii around daylight savings time change"
-  fails "Time#gmtoff returns the correct offset for New Zealand around daylight savings time change"
-  fails "Time#gmtoff returns the correct offset for US Eastern time zone around daylight savings time change"
-  fails "Time#gmtoff returns the offset in seconds between the timezone of time and UTC"
-  fails "Time#gmt_offset given negative offset returns a negative offset"
-  fails "Time#gmt_offset given positive offset returns a positive offset"
-  fails "Time#gmt_offset returns offset as Rational"
-  fails "Time#gmt_offset returns the correct offset for Hawaii around daylight savings time change"
-  fails "Time#gmt_offset returns the correct offset for New Zealand around daylight savings time change"
-  fails "Time#gmt_offset returns the correct offset for US Eastern time zone around daylight savings time change"
-  fails "Time#gmt_offset returns the offset in seconds between the timezone of time and UTC"
-  fails "Time#hash returns a Fixnum"
-  fails "Time#hour returns the hour of the day (0..23) for a local Time"
-  fails "Time#hour returns the hour of the day for a Time with a fixed offset"
-  fails "Time#isdst dst? returns whether time is during daylight saving time"
-  fails "Time#localtime changes the timezone according to the set one"
-  fails "Time#localtime converts self to local time, modifying the receiver"
-  fails "Time#localtime converts time to the UTC offset specified as an Integer number of seconds"
-  fails "Time#localtime raises ArgumentError if the argument represents a value greater than or equal to 86400 seconds"
-  fails "Time#localtime raises ArgumentError if the argument represents a value less than or equal to -86400 seconds"
-  fails "Time#localtime raises ArgumentError if the String argument is not of the form (+|-)HH:MM"
-  fails "Time#localtime returns a Time with a UTC offset of the specified number of Rational seconds"
-  fails "Time#localtime returns a Time with a UTC offset specified as +HH:MM"
-  fails "Time#localtime returns a Time with a UTC offset specified as -HH:MM"
-  fails "Time#localtime returns self"
-  fails "Time#localtime with an argument that responds to #to_int coerces using #to_int"
-  fails "Time#localtime with an argument that responds to #to_r coerces using #to_r"
-  fails "Time#localtime with an argument that responds to #to_str coerces using #to_str"
-  fails "Time#mday returns the day of the month (1..n) for a local Time"
-  fails "Time#mday returns the day of the month for a Time with a fixed offset"
-  fails "Time#min returns the minute of the hour (0..59) for a local Time"
-  fails "Time#min returns the minute of the hour for a Time with a fixed offset"
-  fails "Time#mon returns the four digit year for a Time with a fixed offset"
-  fails "Time#mon returns the month of the year for a local Time"
-  fails "Time#month returns the four digit year for a Time with a fixed offset"
-  fails "Time#month returns the month of the year for a local Time"
-  fails "Time#nsec returns 0 for a Time constructed with a whole number of seconds"
-  fails "Time#nsec returns the nanoseconds part of a Time constructed with a Float number of seconds"
-  fails "Time#nsec returns the nanoseconds part of a Time constructed with a Rational number of seconds"
-  fails "Time#nsec returns the nanoseconds part of a Time constructed with an Float number of microseconds"
-  fails "Time#nsec returns the nanoseconds part of a Time constructed with an Integer number of microseconds"
-  fails "Time#nsec returns the nanoseconds part of a Time constructed with an Rational number of microseconds"
-  fails "Time#strftime with %L formats the milliseconds of the second"
-  fails "Time#strftime with %z formats a local time with negative UTC offset as '-HHMM'"
-  fails "Time#strftime with %z formats a local time with positive UTC offset as '+HHMM'"
-  fails "Time#strftime with %z formats a time with fixed negative offset as '-HHMM'"
-  fails "Time#strftime with %z formats a time with fixed offset as '+/-HH:MM' with ':' specifier"
-  fails "Time#strftime with %z formats a time with fixed offset as '+/-HH:MM:SS' with '::' specifier"
-  fails "Time#strftime with %z formats a time with fixed positive offset as '+HHMM'"
-  fails "Time#strftime with %z formats a UTC time offset as '+0000'"
-  fails "Time#subsec returns 0 as a Fixnum for a Time with a whole number of seconds"
-  fails "Time#subsec returns the fractional seconds as a Rational for a Time constructed with a Float number of seconds"
-  fails "Time#subsec returns the fractional seconds as a Rational for a Time constructed with a Rational number of seconds"
-  fails "Time#subsec returns the fractional seconds as a Rational for a Time constructed with an Float number of microseconds"
-  fails "Time#subsec returns the fractional seconds as a Rational for a Time constructed with an Integer number of microseconds"
-  fails "Time#subsec returns the fractional seconds as a Rational for a Time constructed with an Rational number of microseconds"
-  fails "Time#to_a returns a 10 element array representing the deconstructed time"
-  fails "Time#to_r returns a Rational even for a whole number of seconds"
-  fails "Time#to_r returns the a Rational representing seconds and subseconds since the epoch"
-  fails "Time#usec returns 0 for a Time constructed with an Rational number of microseconds < 1"
-  fails "Time#usec returns the microseconds for time created by Time#local"
-  fails "Time#usec returns the microseconds part of a Time constructed with a Rational number of seconds"
-  fails "Time#usec returns the microseconds part of a Time constructed with an Float number of microseconds > 1"
-  fails "Time#usec returns the microseconds part of a Time constructed with an Integer number of microseconds"
-  fails "Time#usec returns the microseconds part of a Time constructed with an Rational number of microseconds > 1"
-  fails "Time#utc returns the utc representation of time"
-  fails "Time#utc_offset given negative offset returns a negative offset"
-  fails "Time#utc_offset given positive offset returns a positive offset"
-  fails "Time#utc_offset returns offset as Rational"
-  fails "Time#utc_offset returns the correct offset for Hawaii around daylight savings time change"
-  fails "Time#utc_offset returns the correct offset for New Zealand around daylight savings time change"
-  fails "Time#utc_offset returns the correct offset for US Eastern time zone around daylight savings time change"
-  fails "Time#utc_offset returns the offset in seconds between the timezone of time and UTC"
-  fails "Time#wday returns an integer representing the day of the week, 0..6, with Sunday being 0"
-  fails "Time#year returns the four digit year for a local Time as an Integer"
-  fails "Time#year returns the four digit year for a Time with a fixed offset"
-  fails "Time#zone Encoding.default_internal is set doesn't raise errors for a Time with a fixed offset"
-  fails "Time#zone Encoding.default_internal is set returns the string with the default internal encoding"
-  fails "Time#zone returns nil for a Time with a fixed offset"
-  fails "Time#zone returns nil when getting the local time with a fixed offset"
-  fails "Time#zone returns the correct timezone for a local time"
-  fails "Time#zone returns the time zone used for time"
-  fails "Time#zone returns UTC when called on a UTC time"
-  fails "Time.at passed non-Time, non-Numeric with an argument that responds to #to_r coerces using #to_r"
-  fails "Time.at passed Numeric returns a subclass instance on a Time subclass"
-  fails "Time.at passed Time returns a subclass instance"
-  fails "Time.at passed [Integer, Numeric] returns a Time object representing the given number of seconds and Float microseconds since 1970-01-01 00:00:00 UTC"
-  fails "Time.at with a second argument that responds to #to_r coerces using #to_r"
-  fails "Time.gm handles fractional microseconds as a Float"
-  fails "Time.gm handles fractional microseconds as a Rational"
-  fails "Time.gm handles fractional seconds as a Rational"
-  fails "Time.gm handles microseconds"
-  fails "Time.gm ignores fractional seconds if a passed fractional number of microseconds"
-  fails "Time.gm ignores fractional seconds if a passed whole number of microseconds"
-  fails "Time.gm returns subclass instances"
-  fails "Time.local creates a time based on given C-style gmtime arguments, interpreted in the local time zone"
-  fails "Time.local creates a time based on given values, interpreted in the local time zone"
-  fails "Time.local creates the correct time just after dst change"
-  fails "Time.local creates the correct time just before dst change"
-  fails "Time.local handles fractional microseconds as a Float"
-  fails "Time.local handles fractional microseconds as a Rational"
-  fails "Time.local handles fractional seconds as a Rational"
-  fails "Time.local handles microseconds"
-  fails "Time.local ignores fractional seconds if a passed fractional number of microseconds"
-  fails "Time.local ignores fractional seconds if a passed whole number of microseconds"
-  fails "Time.local respects rare old timezones"
-  fails "Time.local returns subclass instances"
-  fails "Time.local timezone changes correctly adjusts the timezone change to 'CEST' on 'Europe/Amsterdam'"
-  fails "Time.local timezone changes correctly adjusts the timezone change to 'EET' on 'Europe/Istanbul'"
-  fails "Time.mktime creates a time based on given C-style gmtime arguments, interpreted in the local time zone"
-  fails "Time.mktime creates a time based on given values, interpreted in the local time zone"
-  fails "Time.mktime creates the correct time just after dst change"
-  fails "Time.mktime creates the correct time just before dst change"
-  fails "Time.mktime handles fractional microseconds as a Float"
-  fails "Time.mktime handles fractional microseconds as a Rational"
-  fails "Time.mktime handles fractional seconds as a Rational"
-  fails "Time.mktime handles microseconds"
-  fails "Time.mktime ignores fractional seconds if a passed fractional number of microseconds"
-  fails "Time.mktime ignores fractional seconds if a passed whole number of microseconds"
-  fails "Time.mktime respects rare old timezones"
-  fails "Time.mktime returns subclass instances"
-  fails "Time.mktime timezone changes correctly adjusts the timezone change to 'CEST' on 'Europe/Amsterdam'"
-  fails "Time.mktime timezone changes correctly adjusts the timezone change to 'EET' on 'Europe/Istanbul'"
-  fails "Time.new creates a subclass instance if called on a subclass"
-  fails "Time.new creates a time based on given values, interpreted in the local time zone"
-  fails "Time.new handles fractional seconds as a Rational"
-  fails "Time.new respects rare old timezones"
-  fails "Time.new returns subclass instances"
-  fails "Time.new timezone changes correctly adjusts the timezone change to 'CEST' on 'Europe/Amsterdam'"
-  fails "Time.new timezone changes correctly adjusts the timezone change to 'EET' on 'Europe/Istanbul'"
-  fails "Time.new with a utc_offset argument adds one hour if the offset minute value is greater than 59"
-  fails "Time.new with a utc_offset argument raises ArgumentError if the argument represents a value greater than or equal to 86400 seconds"
-  fails "Time.new with a utc_offset argument raises ArgumentError if the argument represents a value less than or equal to -86400 seconds"
-  fails "Time.new with a utc_offset argument raises ArgumentError if the hour value is greater than 23"
-  fails "Time.new with a utc_offset argument raises ArgumentError if the String argument is not of the form (+|-)HH:MM"
-  fails "Time.new with a utc_offset argument returns a local Time if the argument is nil"
-  fails "Time.new with a utc_offset argument returns a non-UTC time"
-  fails "Time.new with a utc_offset argument returns a Time with a UTC offset of the specified number of Integer seconds"
-  fails "Time.new with a utc_offset argument returns a Time with a UTC offset of the specified number of Rational seconds"
-  fails "Time.new with a utc_offset argument returns a Time with a UTC offset specified as +HH:MM"
-  fails "Time.new with a utc_offset argument returns a Time with a UTC offset specified as -HH:MM"
-  fails "Time.new with a utc_offset argument with an argument that responds to #to_int coerces using #to_int"
-  fails "Time.new with a utc_offset argument with an argument that responds to #to_r coerces using #to_r"
-  fails "Time.new with a utc_offset argument with an argument that responds to #to_str coerces using #to_str"
-  fails "Time.now creates a subclass instance if called on a subclass"
-  fails "Time.utc handles fractional microseconds as a Float"
-  fails "Time.utc handles fractional microseconds as a Rational"
-  fails "Time.utc handles fractional seconds as a Rational"
-  fails "Time.utc handles microseconds"
-  fails "Time.utc ignores fractional seconds if a passed fractional number of microseconds"
-  fails "Time.utc ignores fractional seconds if a passed whole number of microseconds"
-  fails "Time.utc returns subclass instances"
-end

data/spec/lib/builder_processors_spec.rb

@@ -1,27 +0,0 @@
-require 'lib/spec_helper'
-require 'opal/builder_processors'
-
-describe Opal::Builder::RubyProcessor do
-  it 'compiles ruby to js' do
-    processor = described_class.new('puts 5', '-e')
-    expect(processor.to_s).to include('$puts(5)')
-  end
-
-  describe ':requirable option' do
-    it 'is respected' do
-      processor = described_class.new('puts 5', '-e', requirable: true)
-      expect(processor.to_s).to include('Opal.modules[')
-    end
-
-    it 'defaults to "false"' do
-      processor = described_class.new('puts 5', '-e')
-      expect(processor.to_s).not_to include('Opal.modules[')
-    end
-  end
-
-  it 'fills required_trees' do
-    processor = described_class.new('require_tree "./pippo"', '-e')
-    expect(processor.required_trees).to eq(['pippo'])
-  end
-end
-

data/spec/lib/builder_spec.rb

@@ -1,89 +0,0 @@
-require 'lib/spec_helper'
-require 'opal/builder'
-require 'lib/shared/path_reader_shared'
-
-describe Opal::Builder do
-  subject(:builder) { described_class.new(options) }
-  let(:options) { {} }
-
-  it 'compiles opal' do
-    expect(builder.build('opal').to_s).to match('(Opal);')
-  end
-
-  it 'respect #require_tree calls' do
-    builder.append_paths(File.expand_path('..', __FILE__))
-    expect(builder.build('fixtures/require_tree_test').to_s).to include('Opal.modules["fixtures/required_tree_test/required_file1"]')
-  end
-
-  describe ':stubs' do
-    let(:options) { {stubs: ['foo']} }
-
-    it 'compiles them as empty files' do
-      source = 'require "foo"'
-      expect(builder.default_processor).to receive('new').with(source, anything, anything).once.and_call_original
-      expect(builder.default_processor).to receive('new').with('',     anything, anything).once.and_call_original
-
-      builder.build_str(source, 'bar.rb')
-    end
-  end
-
-  describe ':prerequired' do
-    let(:options) { {prerequired: ['foo']} }
-
-    it 'compiles them as empty files' do
-      source = 'require "foo"'
-      builder.build_str(source, 'bar.rb')
-    end
-  end
-
-  describe ':preload' do
-    let(:options) { {preload: ['base64']} }
-
-    it 'compiles them as empty files' do
-      source = 'puts 5'
-      expect(builder.default_processor).to receive('new').with(anything, 'base64', anything).once.and_call_original
-      expect(builder.default_processor).to receive('new').with(source, anything, anything).once.and_call_original
-
-      builder.build_str(source, 'bar.rb')
-    end
-  end
-
-  describe 'dup' do
-    it 'duplicates internal structures' do
-      b2 = builder.dup
-      b2.should_not equal(builder)
-      [:stubs, :preload, :processors, :path_reader, :prerequired, :compiler_options, :processed].each do |m|
-        b2.send(m).should_not equal(builder.send(m))
-      end
-    end
-  end
-
-  describe 'requiring a native .js file' do
-    it 'can be required without specifying extension' do
-      builder.build_str('require "corelib/runtime"', 'foo')
-      expect(builder.to_s).to start_with('(function(undefined)')
-    end
-
-    it 'can be required specifying extension' do
-      builder.build_str('require "corelib/runtime.js"', 'foo')
-      expect(builder.to_s).to start_with('(function(undefined)')
-    end
-  end
-
-  it 'defaults config from Opal::Config' do
-    Opal::Config.arity_check_enabled = false
-    expect(Opal::Config.arity_check_enabled).to eq(false)
-    expect(Opal::Config.compiler_options[:arity_check]).to eq(false)
-    builder = described_class.new
-    builder.build_str('def foo; end', 'foo')
-    expect(builder.to_s).not_to include('TMP_foo_1.$$parameters = []')
-
-    Opal::Config.arity_check_enabled = true
-    expect(Opal::Config.arity_check_enabled).to eq(true)
-    expect(Opal::Config.compiler_options[:arity_check]).to eq(true)
-    builder = described_class.new
-    builder.build_str('def foo; end', 'foo')
-    expect(builder.to_s).to include('TMP_foo_1.$$parameters = []')
-  end
-
-end

data/spec/lib/cli_runners/phantomjs_spec.rb

@@ -1,39 +0,0 @@
-require 'lib/spec_helper'
-require 'opal/cli_runners/phantomjs'
-require 'stringio'
-
-describe Opal::CliRunners::Phantomjs do
-  # FIXME: Unfotunately there are some issues on 1.9.3, probably
-  #        related to IO.pipe and process spawning in general.
-  before { pending if RUBY_VERSION == '1.9.3' }
-
-  it 'accepts arguments' do
-    expect(output_of(%{
-      var ARGV = JSON.parse(callPhantom(['argv']));
-      callPhantom(['stdout', JSON.stringify(ARGV)]);
-      callPhantom(['exit', 0]);
-    }, ['foo', 'bar'])).to eq('["foo","bar"]')
-  end
-
-  it 'sets env' do
-    ENV['FOO'] = 'BAR'
-    expect(output_of(%{
-      var ENV = JSON.parse(callPhantom(['env']));
-      callPhantom(['stdout', JSON.stringify(ENV)]);
-      callPhantom(['exit', 0]);
-    }, [])).to include(%{"FOO":"BAR"})
-  end
-
-
-  private
-
-  def output_of(*args)
-    read, write = IO.pipe
-    runner = described_class.new(output: write)
-
-    runner.run(*args)
-    write.close
-
-    return read.read
-  end
-end

data/spec/lib/cli_spec.rb

@@ -1,240 +0,0 @@
-require 'lib/spec_helper'
-require 'opal/cli'
-require 'stringio'
-
-describe Opal::CLI do
-  let(:fake_stdout) { StringIO.new }
-  let(:file)    { File.expand_path('../fixtures/opal_file.rb', __FILE__) }
-  let(:options) { {} }
-  subject(:cli) { described_class.new(options) }
-
-  context 'with a file' do
-    let(:options) { {:file => File.open(file)} }
-
-    it 'runs the file' do
-      expect_output_of{ subject.run }.to eq("hi from opal!\n")
-    end
-
-    context 'with lib_only: true' do
-      let(:options) { super().merge lib_only: true }
-
-      it 'raises ArgumentError' do
-        expect{subject.run}.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe ':evals option' do
-    context 'without evals and paths' do
-      it 'raises ArgumentError' do
-        expect { subject.run }.to raise_error(ArgumentError)
-      end
-
-      context 'with lib_only: true and opal require' do
-        let(:options) { super().merge lib_only: true }
-
-        it 'does not raise an error' do
-          expect{subject.run}.not_to raise_error
-        end
-      end
-    end
-
-    context 'with one eval' do
-      let(:options) { {:evals => ['puts "hello"']} }
-
-      it 'executes the code' do
-        expect_output_of{ subject.run }.to eq("hello\n")
-      end
-
-      context 'with lib_only: true' do
-        let(:options) { super().merge lib_only: true }
-
-        it 'raises ArgumentError' do
-          expect{subject.run}.to raise_error(ArgumentError)
-        end
-      end
-    end
-
-    context 'with many evals' do
-      let(:options) { {:evals => ['puts "hello"', 'puts "ciao"']} }
-
-      it 'executes the code' do
-        expect_output_of{ subject.run }.to eq("hello\nciao\n")
-      end
-    end
-  end
-
-  describe ':no_exit option' do
-    context 'when false' do
-      let(:options) { {no_exit: false, compile: true, evals: ['']} }
-      it 'appends a Kernel#exit at the end of the source' do
-        expect_output_of{ subject.run }.to include(".$exit()")
-      end
-    end
-
-    context 'when true' do
-      let(:options) { {no_exit: true, compile: true, evals: ['']} }
-      it 'appends a Kernel#exit at the end of the source' do
-        expect_output_of{ subject.run }.not_to include(".$exit();")
-      end
-    end
-  end
-
-  describe ':lib_only option' do
-    context 'when false' do
-      let(:options) { {lib_only: false, compile: true, evals: [''], skip_opal_require: true, no_exit: true} }
-      it 'appends an empty code block at the end of the source' do
-        expect_output_of{ subject.run }.to include("function(Opal)")
-      end
-    end
-
-    context 'when true' do
-      let(:options) { {lib_only: true, compile: true, no_exit: true} }
-      it 'appends code block at the end of the source' do
-        expect_output_of{ subject.run }.not_to eq("\n")
-      end
-
-      context 'without any require' do
-        let(:options) { {lib_only: true, compile: true, skip_opal_require: true, no_exit: true} }
-        it 'raises ArgumentError' do
-          expect{subject.run}.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-
-  describe ':requires options' do
-    context 'with an absolute path' do
-      let(:options) { {:requires => [file], :evals => ['']} }
-      it 'requires the file' do
-        expect_output_of{ subject.run }.to eq("hi from opal!\n")
-      end
-    end
-
-    context 'with a path relative to a load path' do
-      let(:dir)      { File.dirname(file) }
-      let(:filename) { File.basename(file) }
-      let(:options)  { {:load_paths => [dir], :requires => [filename], :evals => ['']} }
-      it 'requires the file' do
-        expect_output_of{ subject.run }.to eq("hi from opal!\n")
-      end
-    end
-  end
-
-  describe ':gems options' do
-    context 'with a Gem name' do
-      let(:dir)      { File.dirname(file) }
-      let(:filename) { File.basename(file) }
-      let(:gem_name) { 'mspec' }
-      let(:options)  { {:gems => [gem_name], :evals => ['']} }
-
-      it "adds the gem's lib paths to Opal.path" do
-        builder = cli.builder
-
-        spec = Gem::Specification.find_by_name(gem_name)
-        spec.require_paths.each do |require_path|
-          require_path = File.join(spec.gem_dir, require_path)
-          expect(builder.path_reader.send(:file_finder).paths).to include(require_path)
-        end
-      end
-    end
-  end
-
-  describe ':stubs options' do
-    context 'with a stubbed file' do
-      let(:dir)      { File.dirname(file) }
-      let(:filename) { File.basename(file) }
-      let(:stub_name) { 'an_unparsable_lib' }
-      let(:options)  { {:stubs => [stub_name], :evals => ["require #{stub_name.inspect}"]} }
-
-      it "adds the gem's lib paths to Opal.path" do
-        expect_output_of{ subject.run }.to eq('')
-      end
-    end
-  end
-
-  describe ':verbose option' do
-    let(:options)  { {:verbose => true, :evals => ['']} }
-
-    it 'sets the verbose flag (currently unused)' do
-      expect(cli.verbose).to eq(true)
-    end
-  end
-
-  describe ':compile option' do
-    let(:options)  { {:compile => true, :evals => ['puts 2342']} }
-
-    it 'outputs the compiled javascript' do
-      expect_output_of{ subject.run }.to include(".$puts(2342)")
-      expect_output_of{ subject.run }.not_to include("2342\n")
-    end
-  end
-
-  describe ':load_paths options' do
-    let(:dir)      { File.dirname(file) }
-    let(:filename) { File.basename(file) }
-    let(:options)  { {:load_paths => [dir], :requires => [filename], :evals => ['']} }
-    it 'requires files' do
-      expect_output_of{ subject.run }.to eq("hi from opal!\n")
-    end
-  end
-
-  describe ':sexp option' do
-    let(:options) { {evals: ['puts 4'], sexp: true} }
-    it 'prints syntax expressions for the given code' do
-      expect_output_of{ subject.run }.to eq("s(:send, nil, :puts,\n  s(:int, 4))\n")
-    end
-  end
-
-  describe ':map option' do
-    let(:map_path) { "#{Dir.mktmpdir 'opal-map'}/file.map" }
-    let(:options)  { {map: map_path, evals: ['123']} }
-
-    it 'sets the verbose flag (currently unused)' do
-      expect_output_of{ subject.run }.to eq('')
-      expect(File.read(map_path)).to include(%{"version":3})
-    end
-  end
-
-  describe ':parse_comments option' do
-    let(:code) do
-      <<-CODE
-        # multiline
-        # comment
-        def m
-        end
-      CODE
-    end
-    let(:options) { { parse_comments: true, evals: [code], compile: true } }
-
-    it 'sets $$comment prop for compiled methods' do
-      expect_output_of { subject.run }.to include('$$comments = ["# multiline", "# comment"]')
-    end
-  end
-
-  describe ':enable_source_location' do
-    let(:file) { File.expand_path('../fixtures/source_location_test.rb', __FILE__) }
-    let(:options) { { enable_source_location: true, compile: true, file: File.open(file) } }
-
-    it 'sets $$source_location prop for compiled methods' do
-      expect_output_of { subject.run }.to include("source_location_test.rb', 6]")
-    end
-  end
-
-  private
-
-  def expect_output_of
-    @output, _result = output_and_result_of { yield }
-    expect(@output)
-  end
-
-  def output_and_result_of
-    stdout = described_class.stdout
-    described_class.stdout = fake_stdout
-    result = yield
-    output = fake_stdout.tap(&:rewind).read
-    return output, result
-  ensure
-    described_class.stdout = stdout
-  end
-end