opal-cj 0.7.0.beta1

data/spec/lib/compiler_spec.rb

@@ -0,0 +1,197 @@
+require 'lib/spec_helper'
+
+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 "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 "should compile constant lookups" do
+    expect_compiled("Object").to include("Object")
+    expect_compiled("Array").to include("Array")
+  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 "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-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 "skips elsif/else parts" 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
+
+  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'
+      let(:file) { Pathname(__FILE__).join('../fixtures/require_tree_test.rb') }
+
+      it 'parses and resolve #require argument' do
+        compiler = compiler_for(file.read)
+        expect(compiler.required_trees).to eq(['../fixtures/required_tree_test'])
+      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/dependency_resolver_spec.rb

@@ -0,0 +1,40 @@
+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/no_requires.rb

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

data/spec/lib/fixtures/opal_file.rb

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

data/spec/lib/fixtures/require_tree_test.rb

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

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

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

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

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

data/spec/lib/fixtures/requires.rb

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

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

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

data/spec/lib/fixtures/sprockets_require_tree_test.rb

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

data/spec/lib/hike_path_finder_spec.rb

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,13 @@
+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