opal 0.10.6 → 0.11.0.rc1

data/spec/lib/parser/super_spec.rb

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

@@ -1,52 +0,0 @@
-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]]
-        expected = [:call, [:call, [:int, 1], :**, [:arglist, [:int, 2]]], :-@, [:arglist]]
-        parsed("-1 ** 2").should == expected
-        expected = [:call, nil, :puts, [:arglist, [:call, [:int, -1], :hello, [:arglist]]]]
-        parsed("puts -1.hello").should == expected
-      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

@@ -1,19 +0,0 @@
-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
-
-  it "can take multiple symbols" do
-    parsed("undef :a, :b").should == [:undef, [:sym, :a], [:sym, :b]]
-  end
-end

data/spec/lib/parser/unless_spec.rb

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

@@ -1,112 +0,0 @@
-# encoding: utf-8
-
-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, [:arg, :b]], [:block, [:lvar, :b]]]
-      parsed("def a(b, c); c; end").should == [:def, nil, :a, [:args, [:arg, :b], [:arg, :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, [:optarg, :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, [:restarg, :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, [:blockarg, :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 bulitin $-? gvars" do
-    parsed("$-0").should == [:gvar, :$-0]
-    parsed("$-a").should == [:gvar, :$-a]
-    parsed("$-A").should == [:gvar, :$-A]
-  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
-
-  describe 'parsing unicode' do
-    it "works for constants" do
-      parsed("FOOλ = 1").should == [:cdecl, :FOOλ, [:int, 1]]
-    end
-
-    it "works for local variables" do
-      parsed("λ = 1").should == [:lasgn, :λ, [:int, 1]]
-      parsed("fooλ = 1").should == [:lasgn, :fooλ, [:int, 1]]
-      parsed("λfoo = 1").should == [:lasgn, :λfoo, [:int, 1]]
-    end
-  end
-end

data/spec/lib/parser/while_spec.rb

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

@@ -1,20 +0,0 @@
-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/sprockets/erb_spec.rb

@@ -1,38 +0,0 @@
-require 'lib/spec_helper'
-require 'opal/sprockets/erb'
-
-describe Opal::ERB::Processor do
-  let(:pathname) { Pathname("/Code/app/mylib/opal/foo.#{ext}") }
-  let(:environment) { double(Sprockets::Environment,
-    cache: nil,
-    :[] => nil,
-    resolve: pathname.expand_path.to_s,
-    engines: double(keys: %w[.rb .js .erb .opal]),
-  ) }
-  let(:sprockets_context) { double(Sprockets::Context,
-    logical_path: "foo.#{ext}",
-    environment: environment,
-    pathname: pathname,
-    filename: pathname.to_s,
-    root_path: '/Code/app/mylib',
-    is_a?: true,
-  ) }
-  let(:required_assets) { [] }
-  let(:template) { described_class.new { |t| %Q{<% print("") %><a href="<%= url %>"><%= name %></a>} } }
-  before { allow(sprockets_context).to receive(: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(sprockets_context)).to include('"<a href=\""')
-  end
-
-  it 'implicitly requires "erb"' do
-    template.render(sprockets_context)
-    expect(required_assets).to eq(['erb'])
-  end
-end

data/spec/lib/sprockets/path_reader_spec.rb

@@ -1,41 +0,0 @@
-require 'lib/spec_helper'
-require 'lib/shared/path_reader_shared'
-require 'opal/sprockets/path_reader'
-
-describe Opal::Sprockets::PathReader do
-  let(:env) { Sprockets::Environment.new }
-  let(:context) { double('context', depend_on: nil, depend_on_asset: nil) }
-  let(:contents) { File.read(full_path) }
-  let(:full_path) { fixtures_dir.join(logical_path+'.js.rb') }
-  let(:logical_path) { 'sprockets_file' }
-  let(:fixtures_dir) { Pathname('../../fixtures/').expand_path(__FILE__) }
-
-  subject(:path_reader) { described_class.new(env, context) }
-
-  before do
-    Opal.paths.each {|p| env.append_path(p)}
-    env.append_path fixtures_dir
-  end
-
-  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
-
-  it 'reads js files processing their directives' do
-    path              = 'file_with_directives.js'
-    full_path         = fixtures_dir.join(path)
-    required_contents = File.read(fixtures_dir.join('required_file.js')).strip
-    read_contents     = path_reader.read(path)
-    actual_contents   = full_path.read
-
-    expect(actual_contents).to include('//= require')
-    expect(read_contents).not_to include('//= require')
-
-    expect(read_contents).to include(required_contents)
-    expect(actual_contents).not_to include(required_contents)
-  end
-end

data/spec/lib/sprockets/processor_spec.rb

@@ -1,79 +0,0 @@
-require 'lib/spec_helper'
-require 'opal/sprockets/processor'
-
-describe Opal::Processor do
-  let(:pathname) { Pathname("/Code/app/mylib/opal/foo.#{ext}") }
-  let(:environment) { double(Sprockets::Environment,
-    cache: nil,
-    :[] => nil,
-    resolve: pathname.expand_path.to_s,
-    engines: double(keys: %w[.rb .js .opal]),
-  ) }
-  let(:sprockets_context) { double(Sprockets::Context,
-    logical_path: "foo.#{ext}",
-    environment: environment,
-    pathname: pathname,
-    filename: pathname.to_s,
-    root_path: '/Code/app/mylib',
-    is_a?: true,
-  ) }
-
-  %w[.rb .opal].each do |ext|
-    let(:ext) { ext }
-
-    describe %Q{with extension "#{ext}"} do
-      it "is registered for '#{ext}' files" do
-        expect(Sprockets.engines[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(sprockets_context)).to include('"Hello, World!"')
-      end
-    end
-  end
-
-  describe '.stubbed_files' do
-    around do |e|
-      config.stubbed_files.clear
-      e.run
-      config.stubbed_files.clear
-    end
-
-    let(:stubbed_file) { 'foo' }
-    let(:template) { described_class.new { |t| "require #{stubbed_file.inspect}" } }
-    let(:config) { Opal::Config }
-
-    it 'usually require files' do
-      expect(sprockets_context).to receive(:require_asset).with(stubbed_file)
-      template.render(sprockets_context)
-    end
-
-    it 'skips require of stubbed file' do
-      config.stubbed_files << stubbed_file.to_s
-      expect(sprockets_context).not_to receive(:require_asset).with(stubbed_file)
-      template.render(sprockets_context)
-    end
-
-    it 'marks a stubbed file as loaded' do
-      config.stubbed_files << stubbed_file.to_s
-      asset = double(dependencies: [], pathname: Pathname('bar'), logical_path: 'bar')
-      environment.stub(:[]).with('bar.js') { asset }
-      environment.stub(:engines) { {'.rb' => described_class, '.opal' => described_class} }
-
-      code = ::Opal::Sprockets.load_asset('bar')
-      code.should match stubbed_file
-    end
-  end
-
-  describe '.cache_key' do
-    it 'can be reset' do
-      Opal::Config.arity_check_enabled = true
-      old_cache_key = described_class.cache_key
-      Opal::Config.arity_check_enabled = false
-      expect(described_class.cache_key).to eq(old_cache_key)
-      described_class.reset_cache_key!
-      expect(described_class.cache_key).not_to eq(old_cache_key)
-    end
-  end
-end

data/spec/lib/sprockets/server_spec.rb

@@ -1,102 +0,0 @@
-require 'lib/spec_helper'
-require 'sourcemap'
-require 'rack/test'
-
-describe Opal::Server do
-  include Rack::Test::Methods
-
-  let(:maps_prefix) { described_class::SOURCE_MAPS_PREFIX_PATH }
-
-  def app
-    described_class.new { |s|
-      s.main = 'opal'
-      s.debug = false
-      s.append_path File.expand_path('../../fixtures', __FILE__)
-      s.sprockets.logger = Logger.new(nil)
-    }
-  end
-
-  it 'serves assets from /assets' do
-    get '/assets/opal.js'
-    expect(last_response).to be_ok
-  end
-
-  it 'serves assets with complex sprockets requires' do
-    asset = app.sprockets['complex_sprockets']
-    expect(asset).to be_truthy
-
-    assets = asset.to_a.map do |sub_asset|
-      sub_asset.logical_path.gsub(/\.self\.js$/, '.js')
-    end
-
-    %w[
-      no_requires.js
-      jst_file.js
-      required_tree_test/required_file1.js
-      required_tree_test/required_file2.js
-      file_with_directives.js
-    ].each do |logical_path|
-      expect(assets).to include(logical_path)
-    end
-  end
-
-  describe 'source maps' do
-    it 'serves map on a top level file' do
-      get '/assets/source_map.js'
-      expect(last_response).to be_ok
-
-      get maps_prefix+'/source_map.self.map'
-      expect(last_response).to be_ok
-    end
-
-    it 'serves map on a subfolder file' do
-      js_path = '/assets/source_map/subfolder/other_file.self.js'
-      map_path = maps_prefix+'/source_map/subfolder/other_file.self.map'
-
-      get js_path
-
-      expect(last_response).to be_ok
-      received_map_path = extract_map_path(last_response)
-      expect(expand_path(received_map_path, js_path+'/..')).to eq(map_path)
-
-      get maps_prefix+'/source_map/subfolder/other_file.self.map'
-      expect(last_response).to be_ok
-    end
-
-    it 'serves map on a subfolder file' do
-      js_path = '/assets/source_map/subfolder/other_file.self.js'
-      map_path = maps_prefix+'/source_map/subfolder/other_file.self.map'
-
-      get js_path
-
-      expect(last_response).to be_ok
-      received_map_path = extract_map_path(last_response)
-      expect(expand_path(received_map_path, js_path+'/..')).to eq(map_path)
-
-      get maps_prefix+'/source_map/subfolder/other_file.self.map'
-      expect(last_response).to be_ok
-      map = ::SourceMap::Map.from_json(last_response.body)
-      expect(map.sources).to include(maps_prefix+'/source_map/subfolder/other_file.rb')
-    end
-  end
-
-  def extract_map_path(response)
-    source_map_comment_regexp = %r{//# sourceMappingURL=(.*)$}
-
-    case
-    when response.body =~ source_map_comment_regexp
-      body.scan(source_map_comment_regexp).first.first
-    when response.headers['X-SourceMap']
-      response.headers['X-SourceMap']
-    else
-      raise "cannot find source map in response: #{response.inspect}"
-    end
-  end
-
-  def expand_path(file_name, dir_string)
-    path = File.expand_path(file_name, dir_string)
-    # Remove Windows letter and colon (eg. C:) from path
-    path = path[2..-1] if !(RUBY_PLATFORM =~ /mswin|mingw/).nil?
-    path
-  end
-end