opal 0.7.2 → 0.8.0.beta1

data/spec/filters/bugs/struct.rb

@@ -1,12 +1,4 @@
 opal_filter "Struct" do
-  fails "Struct includes Enumerable"
-  fails "Struct anonymous class instance methods includes Enumerable"
-
-  fails "Struct#[] fails when it does not know about the requested attribute"
-  fails "Struct#[] fails if not passed a string, symbol, or integer"
-
-  fails "Struct#[]= fails when trying to assign attributes which don't exist"
-
   fails "Struct#== returns true if the other has all the same fields"
   fails "Struct#== handles recursive structures by returning false if a difference can be found"
 
@@ -19,9 +11,6 @@ opal_filter "Struct" do
 
   fails "Struct#members does not override the instance accessor method"
 
-  fails "Struct#to_h returns a Hash with members as keys"
-  fails "Struct#to_h returns a Hash that is independent from the struct"
-
   fails "Struct#initialize can be overriden"
 
   fails "Struct#inspect returns a string representation of some kind"
@@ -37,9 +26,4 @@ opal_filter "Struct" do
   fails "Struct.new does not create a constant with symbol as first argument"
   fails "Struct.new creates a new anonymous class with nil first argument"
   fails "Struct.new calls to_str on its first argument (constant name)"
-
-  fails "Struct#values_at fails when passed unsupported types"
-  fails "Struct#values_at returns an array of values"
-
-  fails "Struct anonymous class instance methods Enumerable methods should work"
 end

data/spec/filters/unsupported/encoding.rb

@@ -41,6 +41,8 @@ opal_filter "Encoding" do
   fails "String.allocate returns a fully-formed String"
   fails "String.allocate returns a binary String"
 
+  fails "String.new returns a binary String"
+
   fails "String#capitalize is locale insensitive (only upcases a-z and only downcases A-Z)"
 
   fails "String#chars is unicode aware"
@@ -58,6 +60,7 @@ opal_filter "Encoding" do
   fails "String#gsub with pattern and block uses the compatible encoding if they are compatible"
   fails "String#gsub with pattern and block raises an Encoding::CompatibilityError if the encodings are not compatible"
   fails "String#gsub with pattern and block replaces the incompatible part properly even if the encodings are not compatible"
+  fails "String#gsub with pattern and block raises an ArgumentError if encoding is not valid"
 
   fails "String#initialize with an argument carries over the encoding invalidity"
 
@@ -80,6 +83,10 @@ opal_filter "Encoding" do
   fails "Magic comment must be at the first line"
   fails "Magic comment is case-insensitive"
   fails "Magic comment determines __ENCODING__"
+
+  # Opal uses \u notation exclusively for String#inspect
+  fails "String#inspect returns a string with non-printing characters replaced by \\x notation"
+  fails "String#inspect returns a string with a NUL character replaced by \\000"
 end
 
 opal_filter "Regexp.escape" do

data/spec/filters/unsupported/float.rb

@@ -3,4 +3,7 @@ opal_filter "Float" do
   fails "Array#to_s represents a recursive element with '[...]'"
   fails "Array#eql? returns false if any corresponding elements are not #eql?"
   fails "Set#eql? returns true when the passed argument is a Set and contains the same elements"
+
+  fails "Kernel#Float raises a TypeError if #to_f returns an Integer"
+  fails "Kernel.Float raises a TypeError if #to_f returns an Integer"
 end

data/spec/filters/unsupported/integer_size.rb

@@ -1,7 +1,59 @@
 opal_filter "fixnum and array size" do
   fails "Array#slice raises a RangeError when the length is out of range of Fixnum"
   fails "Array#slice raises a RangeError when the start index is out of range of Fixnum"
+
   fails "Array#fill with (filler, index, length) raises an ArgumentError or RangeError for too-large sizes"
+
   fails "Array#[] raises a RangeError when the length is out of range of Fixnum"
   fails "Array#[] raises a RangeError when the start index is out of range of Fixnum"
+
+  fails "Kernel.Integer returns a Fixnum or Bignum object"
+  fails "Kernel#Integer returns a Fixnum or Bignum object"
+
+  fails "String#% supports negative bignums with %u or %d"
+
+  fails "String#to_i with bases parses a String in base 2"
+  fails "String#to_i with bases parses a String in base 3"
+  fails "String#to_i with bases parses a String in base 4"
+  fails "String#to_i with bases parses a String in base 5"
+  fails "String#to_i with bases parses a String in base 6"
+  fails "String#to_i with bases parses a String in base 7"
+  fails "String#to_i with bases parses a String in base 8"
+  fails "String#to_i with bases parses a String in base 9"
+  fails "String#to_i with bases parses a String in base 10"
+  fails "String#to_i with bases parses a String in base 11"
+  fails "String#to_i with bases parses a String in base 12"
+  fails "String#to_i with bases parses a String in base 13"
+  fails "String#to_i with bases parses a String in base 14"
+  fails "String#to_i with bases parses a String in base 15"
+  fails "String#to_i with bases parses a String in base 16"
+  fails "String#to_i with bases parses a String in base 17"
+  fails "String#to_i with bases parses a String in base 18"
+  fails "String#to_i with bases parses a String in base 19"
+  fails "String#to_i with bases parses a String in base 20"
+  fails "String#to_i with bases parses a String in base 21"
+  fails "String#to_i with bases parses a String in base 22"
+  fails "String#to_i with bases parses a String in base 23"
+  fails "String#to_i with bases parses a String in base 24"
+  fails "String#to_i with bases parses a String in base 25"
+  fails "String#to_i with bases parses a String in base 26"
+  fails "String#to_i with bases parses a String in base 27"
+  fails "String#to_i with bases parses a String in base 28"
+  fails "String#to_i with bases parses a String in base 29"
+  fails "String#to_i with bases parses a String in base 30"
+  fails "String#to_i with bases parses a String in base 31"
+  fails "String#to_i with bases parses a String in base 32"
+  fails "String#to_i with bases parses a String in base 33"
+  fails "String#to_i with bases parses a String in base 34"
+  fails "String#to_i with bases parses a String in base 35"
+  fails "String#to_i with bases parses a String in base 36"
+
+  fails "Fixnum#<< with n << m returns a Bignum == fixnum_min() * 2 when fixnum_min() << 1 and n < 0"
+  fails "Fixnum#<< with n << m returns a Bignum == fixnum_max() * 2 when fixnum_max() << 1 and n > 0"
+  fails "Fixnum#<< with n << m returns 0 when m < 0 and m is a Bignum"
+  fails "Fixnum#<< with n << m returns 0 when m < 0 and m == p where 2**p > n >= 2**(p-1)"
+
+  fails "Fixnum#>> with n >> m returns a Bignum == fixnum_max() * 2 when fixnum_max() >> -1 and n > 0"
+  fails "Fixnum#>> with n >> m returns a Bignum == fixnum_min() * 2 when fixnum_min() >> -1 and n < 0"
+  fails "Fixnum#>> with n >> m returns 0 when m is a Bignum"
 end

data/spec/filters/unsupported/marshal.rb

@@ -0,0 +1,4 @@
+opal_filter "Singleton" do
+  fails "Singleton#_dump returns an empty string"
+  fails "Singleton#_dump returns an empty string from a singleton subclass"
+end

data/spec/filters/unsupported/mutable_strings.rb

@@ -1,4 +1,21 @@
 opal_filter "Mutable strings are not supported in Opal" do
+  fails "String.new returns a new string given a string argument"
+  fails "String.new returns a fully-formed String"
+
+  fails "String#+ when self is in an ASCII-incompatible encoding incompatible with the argument's encoding uses self's encoding if both are empty"
+  fails "String#+ when self is in an ASCII-incompatible encoding incompatible with the argument's encoding uses self's encoding if the argument is empty"
+  fails "String#+ when self is in an ASCII-incompatible encoding incompatible with the argument's encoding uses the argument's encoding if self is empty"
+  fails "String#+ when self is in an ASCII-incompatible encoding incompatible with the argument's encoding raises Encoding::CompatibilityError if neither are empty"
+  fails "String#+ when the argument is in an ASCII-incompatible encoding incompatible with self's encoding uses self's encoding if both are empty"
+  fails "String#+ when the argument is in an ASCII-incompatible encoding incompatible with self's encoding uses self's encoding if the argument is empty"
+  fails "String#+ when the argument is in an ASCII-incompatible encoding incompatible with self's encoding uses the argument's encoding if self is empty"
+  fails "String#+ when the argument is in an ASCII-incompatible encoding incompatible with self's encoding raises Encoding::CompatibilityError if neither are empty"
+  fails "String#+ when self and the argument are in different ASCII-compatible encodings uses self's encoding if both are ASCII-only"
+  fails "String#+ when self and the argument are in different ASCII-compatible encodings uses self's encoding if the argument is ASCII-only"
+  fails "String#+ when self and the argument are in different ASCII-compatible encodings uses the argument's encoding if self is ASCII-only"
+  fails "String#+ when self and the argument are in different ASCII-compatible encodings raises Encoding::CompatibilityError if neither are ASCII-only"
+  fails "String#+ when self is ASCII-8BIT and argument is US-ASCII uses ASCII-8BIT encoding"
+
   fails "String#upcase! raises a RuntimeError when self is frozen"
   fails "String#upcase! returns nil if no modifications were made"
   fails "String#upcase! modifies self in place"
@@ -98,6 +115,8 @@ opal_filter "Mutable strings are not supported in Opal" do
   fails "String#chop! raises a RuntimeError on a frozen instance that is modified"
   fails "String#chop! raises a RuntimeError on a frozen instance that would not be modified"
 
+  fails "String#sub with pattern and block doesn't raise a RuntimeError if the string is modified while substituting"
+
   fails "String#gsub! with pattern and Hash returns self with all occurrences of pattern replaced with the value of the corresponding hash key"
   fails "String#gsub! with pattern and Hash ignores keys that don't correspond to matches"
   fails "String#gsub! with pattern and Hash replaces self with an empty string if the pattern matches but the hash specifies no replacements"
@@ -126,6 +145,7 @@ opal_filter "Mutable strings are not supported in Opal" do
   fails "String#gsub! with pattern and block uses the compatible encoding if they are compatible"
   fails "String#gsub! with pattern and block raises an Encoding::CompatibilityError if the encodings are not compatible"
   fails "String#gsub! with pattern and block replaces the incompatible part properly even if the encodings are not compatible"
+  fails "String#gsub! with pattern and block raises an ArgumentError if encoding is not valid"
 
   fails "String#lstrip! modifies self in place and returns self"
   fails "String#lstrip! returns nil if no modifications were made"
@@ -358,4 +378,21 @@ opal_filter "Mutable strings are not supported in Opal" do
   fails "String#concat when self and the argument are in different ASCII-compatible encodings uses the argument's encoding if self is ASCII-only"
   fails "String#concat when self and the argument are in different ASCII-compatible encodings raises Encoding::CompatibilityError if neither are ASCII-only"
   fails "String#concat when self is ASCII-8BIT and argument is US-ASCII uses ASCII-8BIT encoding"
+
+  fails "String#dup does not modify the original string when changing dupped string"
+
+  fails "String#each_line does not care if the string is modified while substituting"
+  fails "String#lines does not care if the string is modified while substituting"
+
+  fails "String#initialize with an argument raises a RuntimeError on a frozen instance when self-replacing"
+  fails "String#initialize with an argument raises a RuntimeError on a frozen instance that is modified"
+  fails "String#initialize with an argument raises a TypeError if other can't be converted to string"
+  fails "String#initialize with an argument tries to convert other to string using to_str"
+  fails "String#initialize with an argument replaces the encoding of self with that of other"
+  fails "String#initialize with an argument does not trust self if other is trusted"
+  fails "String#initialize with an argument untrusts self if other is untrusted"
+  fails "String#initialize with an argument does not untaint self if other is untainted"
+  fails "String#initialize with an argument taints self if other is tainted"
+  fails "String#initialize with an argument replaces the content of self with other"
+  fails "String#initialize with an argument returns self"
 end

data/spec/filters/unsupported/private_methods.rb

@@ -40,5 +40,16 @@ opal_filter "Private methods" do
 
   fails "Math#atanh is a private instance method"
 
+  fails "Kernel has private instance method Array()"
+  fails "Kernel has private instance method Hash()"
+  fails "Kernel#Integer is a private method"
+  fails "Kernel#Float is a private method"
+  fails "Kernel#format is a private method"
+  fails "Kernel#sprintf is a private method"
+  fails "Kernel#String is a private method"
   fails "Kernel#warn is a private method"
+
+  fails "Module#instance_methods makes a private Object instance method public in Kernel"
+
+  fails "String#initialize is a private method"
 end

data/spec/filters/unsupported/rational_numbers.rb

@@ -0,0 +1,4 @@
+opal_filter "rational_numbers" do
+  fails "Kernel.Integer calls to_i on Rationals"
+  fails "Kernel#Integer calls to_i on Rationals"
+end

data/spec/filters/unsupported/regular_expressions.rb

@@ -0,0 +1,47 @@
+opal_filter "regular_expressions" do
+  fails "MatchData#[Symbol] returns the corresponding named match when given a Symbol"
+  fails "MatchData#[Symbol] returns the corresponding named match when given a String"
+  fails "MatchData#[Symbol] returns the matching version of multiple corresponding named match"
+  fails "MatchData#[Symbol] returns the last match when multiple named matches exist with the same name"
+  fails "MatchData#[Symbol] returns nil on non-matching named matches"
+  fails "MatchData#[Symbol] raises an IndexError if there is no named match corresponding to the Symbol"
+  fails "MatchData#[Symbol] raises an IndexError if there is no named match corresponding to the String"
+  fails "MatchData#[Symbol] returns matches in the String's encoding"
+
+  fails "MatchData#begin returns the offset of the start of the nth element"
+  fails "MatchData#begin returns nil when the nth match isn't found"
+  fails "MatchData#begin returns the offset for multi byte strings"
+  fails "MatchData#begin returns the offset for multi byte strings with unicode regexp"
+
+  fails "MatchData#end returns the offset of the end of the nth element"
+  fails "MatchData#end returns nil when the nth match isn't found"
+  fails "MatchData#end returns the offset for multi byte strings"
+  fails "MatchData#end returns the offset for multi byte strings with unicode regexp"
+
+  fails "MatchData#names returns an Array"
+  fails "MatchData#names sets each element to a String"
+  fails "MatchData#names returns the names of the named capture groups"
+  fails "MatchData#names returns [] if there were no named captures"
+  fails "MatchData#names returns each name only once"
+  fails "MatchData#names equals Regexp#names"
+
+  fails "MatchData#offset returns a two element array with the begin and end of the nth match"
+  fails "MatchData#offset returns [nil, nil] when the nth match isn't found"
+  fails "MatchData#offset returns the offset for multi byte strings"
+  fails "MatchData#offset returns the offset for multi byte strings with unicode regexp"
+
+  fails "MatchData#regexp returns the pattern used in the match"
+
+  fails "String#gsub with pattern and replacement replaces \\k named backreferences with the regexp's corresponding capture"
+  fails "String#gsub with pattern and replacement doesn't freak out when replacing ^" #Only fails "Text\nFoo".gsub(/^/, ' ').should == " Text\n Foo"
+  fails "String#gsub with pattern and replacement supports \\G which matches at the beginning of the remaining (non-matched) string"
+  fails "String#gsub with pattern and replacement returns a copy of self with all occurrences of pattern replaced with replacement" #Only fails str.gsub(/\Ah\S+\s*/, "huh? ").should == "huh? homely world. hah!"
+
+  fails "String#index with Regexp supports \\G which matches at the given start offset"
+
+  fails "String#match matches \\G at the start of the string"
+
+  fails "String#scan supports \\G which matches the end of the previous match / string start for first match"
+
+  fails "String#sub with pattern, replacement supports \\G which matches at the beginning of the string"
+end

data/spec/filters/unsupported/symbols.rb

@@ -7,4 +7,11 @@ opal_filter "Symbols" do
   fails "A Symbol literal can be created by the %s-delimited expression"
   fails "A Symbol literal can contain null in the string"
   fails "A Symbol literal can be an empty string"
+
+  fails "String#each_line raises a TypeError when the separator is a symbol"
+  fails "String#gsub with pattern and Hash ignores non-String keys"
+  fails "String#index raises a TypeError if passed a Symbol"
+  fails "String#lines raises a TypeError when the separator is a symbol"
+  fails "String#sub with pattern and Hash ignores non-String keys"
+  fails "String#upto does not work with symbols"
 end

data/spec/filters/unsupported/tainted.rb

@@ -67,6 +67,14 @@ opal_filter 'tainted' do
   fails "Hash#to_s returns a tainted string if self is tainted and not empty"
   fails "Hash#inspect returns a tainted string if self is tainted and not empty"
 
+  fails "String#% always taints the result when the format string is tainted"
+  fails "String#% taints result for %p when argument.inspect is tainted"
+  fails "String#% taints result for %s when argument is tainted"
+
+  fails "String#+ taints the result when self or other is tainted"
+
+  fails "String#* always taints the result when self is tainted"
+
   fails "String#[] with index, length always taints resulting strings when self is tainted"
   fails "String#[] with Range always taints resulting strings when self is tainted"
   fails "String#[] with Regexp always taints resulting strings when self or regexp is tainted"
@@ -90,12 +98,16 @@ opal_filter 'tainted' do
 
   fails "String#chop taints result when self is tainted"
 
+  fails "String#delete taints result when self is tainted"
+
   fails "String#each_line taints substrings that are passed to the block if self is tainted"
 
   fails "String#gsub with pattern and replacement taints the result if the original string or replacement is tainted"
   fails "String#gsub with pattern and Hash taints the result if the original string is tainted"
   fails "String#gsub with pattern and Hash taints the result if a hash value is tainted"
 
+  fails "String#inspect taints the result if self is tainted"
+
   fails "String#lines taints substrings that are passed to the block if self is tainted"
 
   fails "String#ljust with length, padding taints result when self or padstr is tainted"
@@ -110,9 +122,17 @@ opal_filter 'tainted' do
   fails "String#rjust with length, padding taints result when self or padstr is tainted"
   fails "String#rjust with length, padding when padding is tainted and self is untainted returns a tainted string if and only if length is longer than self"
 
-
   fails "String#rstrip taints the result when self is tainted"
 
+  fails "String#scan taints the results if the String argument is tainted"
+  fails "String#scan taints the results when passed a String argument if self is tainted"
+  fails "String#scan taints the results if the Regexp argument is tainted"
+  fails "String#scan taints the results when passed a Regexp argument if self is tainted"
+  fails "String#scan with pattern and block taints the results if the String argument is tainted"
+  fails "String#scan with pattern and block taints the results when passed a String argument if self is tainted"
+  fails "String#scan with pattern and block taints the results if the Regexp argument is tainted"
+  fails "String#scan with pattern and block taints the results when passed a Regexp argument if self is tainted"
+
   fails "String#slice with index, length always taints resulting strings when self is tainted"
   fails "String#slice with Range always taints resulting strings when self is tainted"
   fails "String#slice with Regexp always taints resulting strings when self or regexp is tainted"
@@ -132,6 +152,8 @@ opal_filter 'tainted' do
 
   fails "String#sub with pattern, replacement taints the result if the original string or replacement is tainted"
   fails "String#sub with pattern and block taints the result if the original string or replacement is tainted"
+  fails "String#sub with pattern and Hash taints the result if a hash value is tainted"
+  fails "String#sub with pattern and Hash taints the result if the original string is tainted"
 
   fails "String#succ taints the result if self is tainted"
 

data/spec/filters/unsupported/trusted.rb

@@ -78,6 +78,11 @@ opal_filter "Object#trusted/untrusted" do
   fails "String#gsub with pattern and Hash untrusts the result if a hash value is untrusted"
   fails "String#gsub with pattern and block untrusts the result if the original string or replacement is untrusted"
 
+  fails "String#inspect untrusts the result if self is untrusted"
+
+  fails "String#sub with pattern and Hash untrusts the result if the original string is untrusted"
+  fails "String#sub with pattern and Hash untrusts the result if a hash value is untrusted"
+
   fails "MatchData#pre_match keeps untrusted status from the source string"
   fails "MatchData#post_match keeps untrusted status from the source string"
 end

data/spec/lib/fixtures/complex_sprockets.js.rb.erb

@@ -0,0 +1,4 @@
+#= require no_requires
+//= require jst_file
+#= require_tree ./required_tree_test
+require 'file_with_directives'

data/spec/lib/fixtures/jst_file.js.jst

@@ -0,0 +1 @@
+#= require sprockets_file

data/spec/lib/parser/call_spec.rb

@@ -144,3 +144,22 @@ describe "Command calls without a space" do
                                        [:arglist, [:sym, :+]]]
   end
 end
+
+describe 'Operator calls followed by parens' do
+  it 'correctly parses parens' do
+    parsed('1/(2)').should == [:call, [:int, 1], '/'.to_sym, [:arglist, [:paren, [:int, 2]]]]
+    parsed('1*(2)').should == [:call, [:int, 1], '*'.to_sym, [:arglist, [:paren, [:int, 2]]]]
+    parsed('1+(2)').should == [:call, [:int, 1], '+'.to_sym, [:arglist, [:paren, [:int, 2]]]]
+    parsed('1-(2)').should == [:call, [:int, 1], '-'.to_sym, [:arglist, [:paren, [:int, 2]]]]
+  end
+end
+
+describe 'Calls with trailing comma' do
+  it 'parses correctly' do
+    parsed('foo(1,)').should == [:call, nil, :foo, [:arglist, [:int, 1]]]
+    parsed('foo(1, 2,)').should == [:call, nil, :foo, [:arglist, [:int, 1], [:int, 2]]]
+
+    parsed('foo(a: 100,)').should == [:call, nil, :foo, [:arglist,
+      [:hash, [:sym, :a], [:int, 100]]]]
+  end
+end

data/spec/lib/parser/def_spec.rb

@@ -70,5 +70,11 @@ describe "The def keyword" do
     it "should parse combinations of keyword args" do
       parsed("def foo(a:, b: 1, **c); end")[3].should == [:args, [:kwarg, :a], [:kwoptarg, :b, [:int, 1]], [:kwrestarg, :c]]
     end
+
+    it "should parse keywords without parens" do
+      parsed("def foo a:; end")[3].should == [:args, [:kwarg, :a]]
+      parsed("def foo a:, b:; end")[3].should == [:args, [:kwarg, :a], [:kwarg, :b]]
+      parsed("def foo a: 1, b: 2; end")[3].should == [:args, [:kwoptarg, :a, [:int, 1]], [:kwoptarg, :b, [:int, 2]]]
+    end
   end
 end

data/spec/lib/sprockets/erb_spec.rb

@@ -3,10 +3,23 @@ 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(: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 { _context.stub(:require_asset) {|asset| required_assets << asset } }
+  before { sprockets_context.stub(:require_asset) {|asset| required_assets << asset } }
 
   let(:ext) { 'opalerb' }
 
@@ -15,11 +28,11 @@ describe Opal::ERB::Processor do
   end
 
   it 'renders the template' do
-    expect(template.render(_context)).to include('"<a href=\""')
+    expect(template.render(sprockets_context)).to include('"<a href=\""')
   end
 
   it 'implicitly requires "erb"' do
-    template.render(_context)
+    template.render(sprockets_context)
     expect(required_assets).to eq(['erb'])
   end
 end

data/spec/lib/sprockets/processor_spec.rb

@@ -3,33 +3,65 @@ 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') }
+  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,
+  ) }
 
-  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|
+  %w[.rb .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)
+    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(_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!"') }
+        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