opal 1.0.3 → 1.1.1.rc1

data/spec/lib/builder_processors_spec.rb

@@ -0,0 +1,44 @@
+require 'lib/spec_helper'
+require 'opal/builder_processors'
+
+RSpec.describe Opal::BuilderProcessors::JsProcessor do
+  it 'maps to one fragment per line' do
+    processor = described_class.new("line1\n line2\n  line3", 'file.js')
+    expect(processor.source_map.fragments.map(&:code)).to eq([
+      "line1\n",
+      " line2\n",
+      "  line3\n",
+      "Opal.loaded([\"file.js\"]);",
+    ])
+  end
+
+  it 'adds loading code at the end of the source' do
+    processor = described_class.new("line1\n line2\n  line3", 'file.js')
+    expect(processor.source).to eq(%Q{line1\n line2\n  line3\nOpal.loaded(["file.js"]);})
+  end
+end
+
+RSpec.describe Opal::BuilderProcessors::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

@@ -0,0 +1,133 @@
+require 'lib/spec_helper'
+require 'opal/builder'
+
+RSpec.describe Opal::Builder do
+  subject(:builder) { described_class.new(options) }
+  let(:options) { {} }
+  let(:ruby_processor) { Opal::BuilderProcessors::RubyProcessor }
+
+  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(ruby_processor).to receive('new').with(source, anything, anything).once.and_call_original
+      expect(ruby_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(ruby_processor).to receive('new').with(anything, './base64.rb', anything).once.and_call_original
+      expect(ruby_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(global_object)")
+    end
+
+    it 'can be required specifying extension' do
+      builder.build_str('require "corelib/runtime.js"', 'foo')
+      expect(builder.to_s).to start_with("(function(global_object)")
+    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('$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('$foo$1.$$parameters = []')
+  end
+
+  describe '#missing_require_severity' do
+    it 'defaults to warning' do
+      expect(builder.missing_require_severity).to eq(:error)
+    end
+
+    context 'when set to :warning' do
+      let(:options) { {missing_require_severity: :warning} }
+      it 'warns the user' do
+        expect(builder.missing_require_severity).to eq(:warning)
+        expect(builder).to receive(:warn) { |message| expect(message).to start_with(%{can't find file: "non-existen-file"}) }.at_least(1)
+        builder.build_str("require 'non-existen-file'", 'foo.rb')
+      end
+    end
+
+    context 'when set to :ignore' do
+      let(:options) { {missing_require_severity: :ignore} }
+      it 'does nothing' do
+        expect(builder.missing_require_severity).to eq(:ignore)
+        expect(builder).not_to receive(:warn)
+        expect{ builder.build_str("require 'non-existen-file'", 'foo.rb') }.not_to raise_error
+      end
+    end
+
+    context 'when set to :error' do
+      let(:options) { {missing_require_severity: :error} }
+      it 'raises MissingRequire' do
+        expect(builder.missing_require_severity).to eq(:error)
+        expect(builder).not_to receive(:warn)
+        expect{ builder.build_str("require 'non-existen-file'", 'foo.rb') }.to raise_error(described_class::MissingRequire)
+      end
+    end
+  end
+
+  describe ':requirable' do
+    it 'it uses relative paths as module names' do
+      expect(builder.build('stringio', requirable: true).to_s).to include(%{Opal.modules["stringio"]})
+    end
+  end
+
+  describe ':requirable' do
+    it 'it uses front slash as module name' do
+      expect(builder.build('opal/platform', requirable: true).to_s).to include(%{Opal.modules["opal/platform"]})
+    end
+  end
+end

data/spec/lib/cli_runners/server_spec.rb

@@ -0,0 +1,25 @@
+require 'lib/spec_helper'
+require 'opal/cli_runners'
+require 'rack/test'
+
+RSpec.describe Opal::CliRunners::Server do
+  include Rack::Test::Methods
+
+  def app
+    @app
+  end
+
+  it 'starts a server for the given code' do
+    expect(Rack::Server).to receive(:start) do |options|
+      @app = options[:app]
+      expect(options[:Port]).to eq(1234)
+    end
+
+    builder = Opal::Builder.new
+    builder.build_str("puts 123", "app.rb")
+    described_class.call(builder: builder, options: {port: 1234})
+
+    get '/cli_runner.js'
+    expect(last_response.body).to include(".$puts(123)")
+  end
+end

data/spec/lib/cli_runners_spec.rb

@@ -0,0 +1,16 @@
+require 'lib/spec_helper'
+require 'opal/cli_runners'
+
+RSpec.describe Opal::CliRunners do
+  around do |example|
+    original_register = described_class.instance_variable_get :@register
+    example.run
+    described_class.instance_variable_set :@register, original_register
+  end
+
+  describe '.alias_runner' do
+    it 'aliases between runner names' do
+      expect(described_class[:node]).to eq(described_class[:nodejs])
+    end
+  end
+end

data/spec/lib/cli_spec.rb

@@ -0,0 +1,256 @@
+require 'lib/spec_helper'
+require 'opal/cli'
+require 'stringio'
+require 'tmpdir'
+
+RSpec.describe Opal::CLI do
+  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, runner: :compiler, 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, runner: :compiler, 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, runner: :compiler, 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, runner: :compiler, 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, runner: :compiler, 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 ':rbrequires options' do
+    context 'when set' do
+      let(:options) { {:rbrequires => ["some_nonexisting_require"], :evals => [''] } }
+      it 'requires the file before compiling' do
+        expect{ subject.run }.to raise_error(LoadError)
+      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) { 'ast' }
+      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 ':runner option' do
+    context 'when :compile' do
+      let(:options)  { {runner: :compiler, 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
+
+      context 'with the :map_file runner option' do
+        let(:map_file) { "#{Dir.mktmpdir 'opal-map'}/file.map" }
+        let(:runner_options)  { { map_file: map_file } }
+        let(:options) { super().merge(runner_options: runner_options) }
+
+        it 'writes the map file to the specified path' do
+          expect_output_of{ subject.run }.to include(".$puts(2342)")
+          expect_output_of{ subject.run }.not_to include("2342\n")
+          expect(File.read(map_file)).to include(%{"version":3})
+        end
+      end
+    end
+
+    # TODO: test more runners
+  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 ':parse_comments option' do
+    let(:code) do
+      <<-CODE
+        # multiline
+        # comment
+        def m
+        end
+      CODE
+    end
+    let(:options) { { parse_comments: true, evals: [code], runner: :compiler } }
+
+    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, runner: :compiler, 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
+    fake_stdout = StringIO.new
+    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