opal-wedge 0.9.0.dev

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, [: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 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,36 @@
+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 }
+
+    it 'works with absolute paths' do
+      expect(path_reader.read(File.expand_path(__FILE__))).not_to be_nil
+    end
+
+    it 'works with relative paths starting with ./' do
+      expect(path_reader.read('./spec/lib/shared/path_reader_shared.rb')).not_to be_nil
+    end
+
+    it 'works with absolute paths' do
+      expect(path_reader.read("../#{File.basename(Dir.pwd)}/spec/lib/shared/path_reader_shared.rb")).not_to be_nil
+    end
+  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/erb_spec.rb

@@ -0,0 +1,38 @@
+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{<a href="<%= url %>"><%= name %></a>} } }
+  before { sprockets_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(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

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

@@ -0,0 +1,67 @@
+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|
+      described_class.stubbed_files.clear
+      e.run
+      described_class.stubbed_files.clear
+    end
+
+    let(:stubbed_file) { 'foo' }
+    let(:template) { described_class.new { |t| "require #{stubbed_file.inspect}" } }
+
+    it 'usually require files' do
+      sprockets_context.should_receive(:require_asset).with(stubbed_file)
+      template.render(sprockets_context)
+    end
+
+    it 'skips require of stubbed file' do
+      described_class.stub_file stubbed_file
+      sprockets_context.should_not_receive(:require_asset).with(stubbed_file)
+      template.render(sprockets_context)
+    end
+
+    it 'marks a stubbed file as loaded' do
+      described_class.stub_file stubbed_file
+      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 = described_class.load_asset_code(environment, 'bar')
+      code.should match stubbed_file
+    end
+  end
+end