opal-cj 0.7.0.beta1

data/spec/lib/parser/super_spec.rb

@@ -0,0 +1,20 @@
+require 'support/parser_helpers'
+
+describe "The super keyword" do
+  it "should return s(:super) for any arguments" do
+    parsed("super 1").should == [:super, [:arglist, [:int, 1]]]
+    parsed("super 1, 2").should == [:super, [:arglist, [:int, 1], [:int, 2]]]
+    parsed("super 1, *2").should == [:super, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
+  end
+
+  it "should set nil for args when no arguments or parans" do
+    parsed("super").should == [:super, nil]
+  end
+
+  it "should always return s(:super) with :arglist when parans are used" do
+    parsed("super()").should == [:super, [:arglist]]
+    parsed("super(1)").should == [:super, [:arglist, [:int, 1]]]
+    parsed("super(1, 2)").should == [:super, [:arglist, [:int, 1], [:int, 2]]]
+    parsed("super(1, *2)").should == [:super, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
+  end
+end

data/spec/lib/parser/unary_spec.rb

@@ -0,0 +1,48 @@
+require 'support/parser_helpers'
+
+describe Opal::Parser do
+  describe '-@' do
+    context 'with an integer' do
+      it "parses unary op. with the right precedence" do
+        parsed("-1.hello").should == [:call, [:int, -1], :hello, [:arglist]]
+      end
+
+      it "parses unary op. as a method call" do
+        parsed("-1").should == [:int, -1]
+      end
+
+    end
+
+    context 'with a float' do
+      it "parses unary op. with the right precedence" do
+        parsed("-1.23.hello").should == [:call, [:float, -1.23], :hello, [:arglist]]
+      end
+
+      it "parses unary op. as a method call" do
+        parsed("-1.23").should == [:float, -1.23]
+      end
+    end
+  end
+
+  describe '+@' do
+    context 'with an integer' do
+      it "parses unary op. with the right precedence" do
+        parsed("+1.hello").should == [:call, [:int, 1], :hello, [:arglist]]
+      end
+
+      it "parses unary op. as a method call" do
+        parsed("-1").should == [:int, -1]
+      end
+    end
+
+    context 'with a float' do
+      it "parses unary op. with the right precedence" do
+        parsed("+1.23.hello").should == [:call, [:float, 1.23], :hello, [:arglist]]
+      end
+
+      it "parses unary op. as a method call" do
+        parsed("-1.23").should == [:float, -1.23]
+      end
+    end
+  end
+end

data/spec/lib/parser/undef_spec.rb

@@ -0,0 +1,15 @@
+require 'support/parser_helpers'
+
+describe "The undef keyword" do
+  it "returns s(:undef) with the argument as an s(:lit)" do
+    parsed("undef a").should == [:undef, [:sym, :a]]
+  end
+
+  it "appends multiple parts onto end of list" do
+    parsed("undef a, b").should == [:undef, [:sym, :a], [:sym, :b]]
+  end
+
+  it "can take symbols or fitems" do
+    parsed("undef :foo").should == [:undef, [:sym, :foo]]
+  end
+end

data/spec/lib/parser/unless_spec.rb

@@ -0,0 +1,13 @@
+require 'support/parser_helpers'
+
+describe "The unless keyword" do
+  it "returns s(:if) with reversed true and false bodies" do
+    parsed("unless 10; 20; end").should == [:if, [:int, 10], nil, [:int, 20]]
+    parsed("unless 10; 20; 30; end").should == [:if, [:int, 10], nil, [:block, [:int, 20], [:int, 30]]]
+    parsed("unless 10; 20; else; 30; end").should == [:if, [:int, 10], [:int, 30], [:int, 20]]
+  end
+
+  it "returns s(:if) with reversed true and false bodies for prefix unless" do
+    parsed("20 unless 10").should == [:if, [:int, 10], nil, [:int, 20]]
+  end
+end

data/spec/lib/parser/variables_spec.rb

@@ -0,0 +1,92 @@
+require 'support/parser_helpers'
+
+describe Opal::Parser do
+  it "parses instance variables" do
+    parsed("@a").should == [:ivar, :@a]
+    parsed("@A").should == [:ivar, :@A]
+    parsed("@class").should == [:ivar, :@class]
+  end
+
+  it "parses instance variable assignment" do
+    parsed("@a = 1").should == [:iasgn, :@a, [:int, 1]]
+    parsed("@A = 1").should == [:iasgn, :@A, [:int, 1]]
+    parsed("@class = 1").should == [:iasgn, :@class, [:int, 1]]
+  end
+
+  describe "parses local variables" do
+    it "should be created when an identifier is previously assigned to" do
+      parsed("a = 1; a").should == [:block, [:lasgn, :a, [:int, 1]], [:lvar, :a]]
+      parsed("a = 1; a; a").should == [:block, [:lasgn, :a, [:int, 1]], [:lvar, :a], [:lvar, :a]]
+    end
+
+    it "should not be created when no lasgn is previously used on name" do
+      parsed("a").should == [:call, nil, :a, [:arglist]]
+      parsed("a = 1; b").should == [:block, [:lasgn, :a, [:int, 1]], [:call, nil, :b, [:arglist]]]
+    end
+  end
+
+  describe "parses local variables inside a def" do
+    it "should created by a norm arg" do
+      parsed("def a(b); b; end").should == [:def, nil, :a, [:args, :b], [:block, [:lvar, :b]]]
+      parsed("def a(b, c); c; end").should == [:def, nil, :a, [:args, :b, :c], [:block, [:lvar, :c]]]
+    end
+
+    it "should be created by an opt arg" do
+      parsed("def a(b=10); b; end").should == [:def, nil, :a, [:args, :b, [:block, [:lasgn, :b, [:int, 10]]]], [:block, [:lvar, :b]]]
+    end
+
+    it "should be created by a rest arg" do
+      parsed("def a(*b); b; end").should == [:def, nil, :a, [:args, :"*b"], [:block, [:lvar, :b]]]
+    end
+
+    it "should be created by a block arg" do
+      parsed("def a(&b); b; end").should == [:def, nil, :a, [:args, :"&b"], [:block, [:lvar, :b]]]
+    end
+
+    it "should not be created from locals outside the def" do
+      parsed("a = 10; def b; a; end").should == [:block, [:lasgn, :a, [:int, 10]], [:def, nil, :b, [:args], [:block, [:call, nil, :a, [:arglist]]]]]
+    end
+  end
+
+  it "parses local var assignment" do
+    parsed("a = 1").should == [:lasgn, :a, [:int, 1]]
+    parsed("a = 1; b = 2").should == [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]
+  end
+
+  it "parses class variables" do
+    parsed("@@foo").should == [:cvar, :@@foo]
+  end
+
+  it "parses class variable assignment" do
+    parsed("@@foo = 100").should == [:cvdecl, :@@foo, [:int, 100]]
+  end
+
+  it "parses global variables" do
+    parsed("$foo").should == [:gvar, :$foo]
+    parsed("$:").should == [:gvar, :$:]
+  end
+
+  it "parses global var assignment" do
+    parsed("$foo = 1").should == [:gasgn, :$foo, [:int, 1]]
+    parsed("$: = 1").should == [:gasgn, :$:, [:int, 1]]
+  end
+
+  it "parses as s(:nth_ref)" do
+    parsed('$1').first.should == :nth_ref
+  end
+
+  it "references the number 1..9 as first part" do
+    parsed('$1').should == [:nth_ref, '1']
+    parsed('$9').should == [:nth_ref, '9']
+  end
+
+  it "parses constants" do
+    parsed("FOO").should == [:const, :FOO]
+    parsed("BAR").should == [:const, :BAR]
+  end
+
+  it "parses constant assignment" do
+    parsed("FOO = 1").should == [:cdecl, :FOO, [:int, 1]]
+    parsed("FOO = BAR").should == [:cdecl, :FOO, [:const, :BAR]]
+  end
+end

data/spec/lib/parser/while_spec.rb

@@ -0,0 +1,15 @@
+require 'support/parser_helpers'
+
+describe "The while keyword" do
+  it "returns an s(:while) with the given expr, body and true for head" do
+    parsed("while 1; 2; end").should == [:while, [:int, 1], [:int, 2]]
+  end
+
+  it "uses an s(:block) if body has more than one statement" do
+    parsed("while 1; 2; 3; end").should == [:while, [:int, 1], [:block, [:int, 2], [:int, 3]]]
+  end
+
+  it "treats the prefix while statement just like a regular while statement" do
+    parsed("1 while 2").should == [:while, [:int, 2], [:int, 1]]
+  end
+end

data/spec/lib/parser/yield_spec.rb

@@ -0,0 +1,20 @@
+require 'support/parser_helpers'
+
+describe "The yield keyword" do
+  it "should return s(:yield) when no arguments given" do
+    parsed("yield").should == [:yield]
+  end
+
+  it "appends arguments onto end of s(:yield) without an arglist" do
+    parsed("yield 1").should == [:yield, [:int, 1]]
+    parsed("yield 1, 2").should == [:yield, [:int, 1], [:int, 2]]
+    parsed("yield 1, *2").should == [:yield, [:int, 1], [:splat, [:int, 2]]]
+  end
+
+  it "accepts parans for any number of arguments" do
+    parsed("yield()").should == [:yield]
+    parsed("yield(1)").should == [:yield, [:int, 1]]
+    parsed("yield(1, 2)").should == [:yield, [:int, 1], [:int, 2]]
+    parsed("yield(1, *2)").should == [:yield, [:int, 1], [:splat, [:int, 2]]]
+  end
+end

data/spec/lib/path_reader_spec.rb

@@ -0,0 +1,24 @@
+require 'lib/spec_helper'
+require 'lib/shared/path_reader_shared'
+require 'lib/shared/path_finder_shared'
+require 'opal/path_reader'
+
+
+describe Opal::PathReader do
+  subject(:file_reader) { described_class.new(path_finder) }
+  let(:path_finder) { double('path_finder') }
+  let(:path) { 'opal_file' }
+  let(:full_path) { File.expand_path('../fixtures/opal_file.rb', __FILE__) }
+  let(:contents) { File.read(full_path) }
+
+  before do
+    path_finder.stub(:find) {|path| nil}
+    path_finder.stub(:find).with(path).and_return(full_path)
+    path_finder.stub(:paths).and_return(Opal.paths)
+  end
+
+  include_examples :path_finder
+  include_examples :path_reader do
+    let(:path_reader) { file_reader }
+  end
+end

data/spec/lib/shared/path_finder_shared.rb

@@ -0,0 +1,19 @@
+require 'lib/spec_helper'
+
+shared_examples :path_finder do
+  # @param path
+  # the path we want to read
+  #
+  # @param full_path
+  # the expanded path that should be found
+  #
+  it 'returns the full path if the path exists' do
+    expect(path_finder.find(path)).to eq(full_path)
+  end
+
+  it 'returns nil if the path is missing' do
+    expect(path_finder.find('unexpected-path')).to eq(nil)
+  end
+end
+
+

data/spec/lib/shared/path_reader_shared.rb

@@ -0,0 +1,31 @@
+require 'lib/spec_helper'
+
+# Below the helpers expected from a spec that
+# includes these shared examples:
+#
+# @object [PathReader] path_reader the object under test
+# @method [String]     path        the path we want to read
+# @method [String]     contents    the contents we expect to be read
+#
+shared_examples :path_reader do
+  describe '#paths' do
+    it 'is an Enumberable' do
+      expect(path_reader.paths).to be_an(Enumerable)
+    end
+
+    it 'includes Opal.paths' do
+      paths = path_reader.paths.to_a
+      Opal.paths.each { |path| expect(paths).to include(path) }
+    end
+  end
+
+  describe '#read' do
+    it 'responds to #path' do
+      expect(path_reader.read(path)).to eq(contents)
+    end
+
+    it 'returns nil if the file is missing' do
+      expect(path_reader.read('unexpected-path!')).to be_nil
+    end
+  end
+end

data/spec/lib/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'opal'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+  config.before { Opal.instance_variable_set('@paths', nil) }
+end

data/spec/lib/sprockets/environment_spec.rb

@@ -0,0 +1,30 @@
+require 'lib/spec_helper'
+require 'opal/sprockets/environment'
+
+describe Opal::Environment do
+  let(:env) { described_class.new }
+  let(:logical_path) { 'sprockets_file' }
+
+  before { env.append_path File.expand_path('../../fixtures/', __FILE__) }
+
+  it 'compiles Ruby to JS' do
+    expect(env[logical_path].source).to include('$puts(')
+    expect(env[logical_path+'.js'].source).to include('$puts(')
+  end
+
+  describe 'require_tree sprockets directive' do
+    it 'is still supported' do
+      source = env['sprockets_require_tree_test'].source
+      expect(source).to include('required_file1')
+      expect(source).to include('required_file2')
+    end
+  end
+
+  describe 'require_tree helper' do
+    it 'is handled by the processor' do
+      source = env['require_tree_test'].source
+      expect(source).to include('required_file1')
+      expect(source).to include('required_file2')
+    end
+  end
+end

data/spec/lib/sprockets/erb_spec.rb

@@ -0,0 +1,25 @@
+require 'lib/spec_helper'
+require 'opal/sprockets/erb'
+
+describe Opal::ERB::Processor do
+  let(:pathname) { Pathname("/Code/app/mylib/opal/foo.#{ext}") }
+  let(:_context) { double('_context', :logical_path => "foo.#{ext}", :pathname => pathname) }
+  let(:required_assets) { [] }
+  let(:template) { described_class.new { |t| %Q{<a href="<%= url %>"><%= name %></a>} } }
+  before { _context.stub(:require_asset) {|asset| required_assets << asset } }
+
+  let(:ext) { 'opalerb' }
+
+  it "is registered for '.opalerb' files" do
+    expect(Tilt["test.#{ext}"]).to eq(described_class)
+  end
+
+  it 'renders the template' do
+    expect(template.render(_context)).to include('"<a href=\""')
+  end
+
+  it 'implicitly requires "erb"' do
+    template.render(_context)
+    expect(required_assets).to eq(['erb'])
+  end
+end

data/spec/lib/sprockets/path_reader_spec.rb

@@ -0,0 +1,25 @@
+require 'lib/spec_helper'
+require 'lib/shared/path_reader_shared'
+require 'opal/sprockets/path_reader'
+
+describe Opal::Sprockets::PathReader do
+  subject(:path_reader) { described_class.new(env, context) }
+
+  let(:env) { Opal::Environment.new }
+  let(:context) { double('context', depend_on: nil, depend_on_asset: nil) }
+
+  let(:logical_path) { 'sprockets_file' }
+  let(:fixtures_dir) { File.expand_path('../../fixtures/', __FILE__) }
+  let(:full_path) { File.join(fixtures_dir, logical_path+'.js.rb') }
+  let(:contents) { File.read(full_path) }
+
+  before { env.append_path fixtures_dir }
+
+  include_examples :path_reader do
+    let(:path) { logical_path }
+  end
+
+  it 'can read stuff from sprockets env' do
+    expect(path_reader.read(logical_path)).to eq(contents)
+  end
+end

data/spec/lib/sprockets/processor_spec.rb

@@ -0,0 +1,35 @@
+require 'lib/spec_helper'
+require 'opal/sprockets/processor'
+
+describe Opal::Processor do
+  let(:pathname) { Pathname("/Code/app/mylib/opal/foo.#{ext}") }
+  let(:_context) { double('_context', :logical_path => "foo.#{ext}", :pathname => pathname) }
+  let(:env) { double('env') }
+
+  before do
+    env.stub(:resolve) { pathname.expand_path.to_s }
+    env.stub(:[])
+    _context.stub(:environment) { env }
+  end
+
+  %w[rb js.rb opal js.opal].each do |ext|
+    let(:ext) { ext }
+
+    describe %Q{with extension ".#{ext}"} do
+      it "is registered for '.#{ext}' files" do
+        expect(Tilt["test.#{ext}"]).to eq(described_class)
+      end
+
+      it "compiles and evaluates the template on #render" do
+        template = described_class.new { |t| "puts 'Hello, World!'\n" }
+        expect(template.render(_context)).to include('"Hello, World!"')
+      end
+
+      it "can be rendered more than once" do
+        template = described_class.new(_context) { |t| "puts 'Hello, World!'\n" }
+        3.times { expect(template.render(_context)).to include('"Hello, World!"') }
+      end
+    end
+  end
+
+end

data/spec/lib/sprockets/server_spec.rb

@@ -0,0 +1,20 @@
+require 'lib/spec_helper'
+require 'rack/test'
+
+describe Opal::Server do
+  include Rack::Test::Methods
+
+  def app
+    described_class.new { |s|
+      s.main = 'opal'
+      s.debug = false
+      s.sprockets.logger = Logger.new('/dev/null')
+    }
+  end
+
+  it 'serves assets from /assets' do
+    get '/assets/opal.js'
+    expect(last_response).to be_ok
+  end
+
+end