opal 0.9.4 → 0.10.0.beta1

data/spec/filters/bugs/string.rb

@@ -35,7 +35,7 @@ opal_filter "String" do
   fails "String#getbyte returns nil for out-of-bound indexes"
   fails "String#getbyte starts indexing at 0"
   fails "String#slice with Range calls to_int on range arguments"
-  fails "String#split with Regexp includes all captures in the result array"
+  fails "String#split with Regexp includes all captures in the result array" # fails with phantomjs
   fails "String#to_c returns a Complex object"
   fails "String#to_c returns a complex number with 0 as the real part, 0 as the imaginary part for unrecognised Strings"
   fails "String#to_c understands 'a+bi' to mean a complex number with 'a' as the real part, 'b' as the imaginary"

data/spec/filters/bugs/struct.rb

@@ -1,15 +1,3 @@
 opal_filter "Struct" do
   fails "Struct#hash returns the same fixnum for structs with the same content"
-  fails "Struct#initialize can be overriden"
-  fails "Struct#inspect returns a string representation of some kind"
-  fails "Struct#members does not override the instance accessor method"
-  fails "Struct.new calls to_str on its first argument (constant name)"
-  fails "Struct.new creates a new anonymous class with nil first argument"
-  fails "Struct.new does not create a constant with symbol as first argument"
-  fails "Struct.new fails with invalid constant name as first argument"
-  fails "Struct.new on subclasses creates a constant in subclass' namespace"
-  fails "Struct.new on subclasses fails with too many arguments"
-  fails "Struct.new raises a TypeError if object doesn't respond to to_sym"
-  fails "Struct.new raises a TypeError if object is not a Symbol"
-  fails "Struct.new with a block passes same struct class to the block"
 end

data/spec/filters/bugs/time.rb

@@ -24,5 +24,6 @@ opal_filter "Time" do
   fails "Time#to_f returns the float number of seconds + usecs since the epoch"
   fails "Time#to_s formats the fixed offset time following the pattern 'yyyy-MM-dd HH:mm:ss +/-HHMM'"
   fails "Time#zone Encoding.default_internal is set returns an ASCII string"
+  fails "Time.at passed Numeric passed BigDecimal doesn't round input value"
   fails "Time.at passed Numeric roundtrips a Rational produced by #to_r"
 end

data/spec/filters/bugs/unboundmethod.rb

@@ -4,6 +4,7 @@ opal_filter "UnboundMethod" do
   fails "UnboundMethod#== returns true if objects refer to the same method"
   fails "UnboundMethod#== returns true if same method is extracted from the same subclass"
   fails "UnboundMethod#arity for a Method generated by respond_to_missing? returns -1"
+  fails "UnboundMethod#arity returns negative values for method definition 'def m(a=1, *b, c:, d: 2, **k, &l) end'"
   fails "UnboundMethod#arity returns negative values for method definition \n    def m(*) end\n    def n(*a) end"
   fails "UnboundMethod#arity returns negative values for method definition \n    def m(**k, &l) end\n    def n(*a, **k) end\n    def o(a: 1, b: 2, **k) end"
   fails "UnboundMethod#arity returns negative values for method definition \n    def m(*a, b) end\n    def n(*a, b, c) end\n    def o(*a, b, c, d) end"
@@ -15,7 +16,6 @@ opal_filter "UnboundMethod" do
   fails "UnboundMethod#arity returns negative values for method definition \n    def m(a: 1) end\n    def n(a: 1, b: 2) end"
   fails "UnboundMethod#arity returns negative values for method definition \n    def m(a=1) end\n    def n(a=1, b=2) end"
   fails "UnboundMethod#arity returns negative values for method definition \n    def m(a=1, *b) end\n    def n(a=1, b=2, *c) end"
-  fails "UnboundMethod#arity returns negative values for method definition \n    def m(a=1, *b, c:, d: 2, **k, &l) end"
   fails "UnboundMethod#arity returns negative values for method definition \n    def m(a=1, b: 2) end\n    def n(*a, b: 1) end\n    def o(a=1, b: 2) end\n    def p(a=1, *b, c: 2, &l) end"
   fails "UnboundMethod#bind Method returned for obj is equal to one directly returned by obj.method"
   fails "UnboundMethod#bind raises TypeError if object is not kind_of? the Module the method defined in"
@@ -25,6 +25,7 @@ opal_filter "UnboundMethod" do
   fails "UnboundMethod#hash returns the same value for user methods that are eql?"
   fails "UnboundMethod#inspect the String shows the method name, Module defined in and Module extracted from"
   fails "UnboundMethod#owner returns the class/module it was defined in"
+  fails "UnboundMethod#owner returns the new owner for aliased methods on singleton classes"
   fails "UnboundMethod#owner returns the new owner for aliased methods"
   fails "UnboundMethod#source_location returns the last place the method was defined"
   fails "UnboundMethod#source_location returns the location of the original method even if it was aliased"

data/spec/filters/unsupported/freeze.rb

@@ -5,6 +5,8 @@ opal_filter "freezing" do
   fails "Array#rotate! raises a RuntimeError on a frozen array"
   fails "Array#select! on frozen objects returns an Enumerator if no block is given"
   fails "Array#sort does not freezes self during being sorted"
+  fails "Array#sort_by! raises a RuntimeError on a frozen array"
+  fails "Array#sort_by! raises a RuntimeError on an empty frozen array"
   fails "Date constants freezes MONTHNAMES, DAYNAMES, ABBR_MONTHNAMES, ABBR_DAYSNAMES"
   fails "Enumerable#sort doesn't raise an error if #to_a returns a frozen Array"
   fails "Hash#== compares keys with matching hash codes via eql?"
@@ -25,11 +27,11 @@ opal_filter "freezing" do
   fails "Kernel#freeze prevents self from being further modified"
   fails "Kernel#freeze returns self"
   fails "Kernel#frozen? on a Symbol returns true"
-  fails "Kernel#frozen? on true, false and nil returns false"
   fails "Kernel#frozen? returns true if self is frozen"
   fails "MatchData#string returns a frozen copy of the match string"
   fails "Module#alias_method raises RuntimeError if frozen"
   fails "Module#append_features when other is frozen raises a RuntimeError before appending self"
+  fails "Module#const_set on a frozen module raises a RuntimeError before setting the name"
   fails "Module#extend_object when given a frozen object raises a RuntimeError before extending the object"
   fails "Module#remove_method on frozen instance does not raise exceptions when no arguments given"
   fails "Module#remove_method on frozen instance raises a RuntimeError when passed a missing name"

data/spec/filters/unsupported/language.rb

@@ -6,13 +6,6 @@ opal_filter "language" do
   fails "Magic comment is case-insensitive"
   fails "Magic comment must be at the first line"
   fails "Magic comment must be the first token of the line"
-  fails "Regexps with modifers supports /x (extended syntax)"
-  fails "Regexps with modifers supports /o (once)"
-  fails "Regexps with modifers invokes substitutions for /o only once"
-  fails "Regexps with modifers supports modifier combinations"
-  fails "Regexps with modifers supports (?imx-imx) (inline modifiers)"
-  fails "Regexps with modifers supports (?imx-imx:expr) (scoped inline modifiers)"
-  fails "Regexps with modifers supports ASII/Unicode modifiers"
   fails "The defined? keyword for pseudo-variables returns 'expression' for __ENCODING__"
   fails "The defined? keyword when called with a method name having a module as receiver returns nil if the method is private"
   fails "The defined? keyword when called with a method name having a module as receiver returns nil if the method is protected"

data/spec/filters/unsupported/privacy.rb

@@ -16,9 +16,10 @@ opal_filter "private" do
   fails "Module#attr_accessor is a private method"
   fails "Module#attr_reader is a private method"
   fails "Module#attr_writer is a private method"
-  fails "Module#extended is private in its default implementation"
+  fails "Module#define_method when name is not a special private name given an UnboundMethod sets the visibility of the method to the current visibility"
   fails "Module#extend_object is a private method"
   fails "Module#extend_object is called even when private"
+  fails "Module#extended is private in its default implementation"
   fails "Module#included is private in its default implementation"
   fails "Module#method_added is a private instance method"
   fails "Module#method_removed is a private instance method"
@@ -26,11 +27,11 @@ opal_filter "private" do
   fails "Module#module_function is a private method"
   fails "Module#module_function with specific method names can make accessible private methods"
   fails "Module#module_function with specific method names makes the instance methods private"
-  fails "Module#prepended is a private method"
   fails "Module#prepend_features is a private method"
+  fails "Module#prepended is a private method"
   fails "Module#private is a private method"
-  fails "Module#private makes a public Object instance method private in a new module"
   fails "Module#private makes a public Object instance method private in Kernel"
+  fails "Module#private makes a public Object instance method private in a new module"
   fails "Module#private makes the target method uncallable from other types"
   fails "Module#private raises a NameError when given an undefined name"
   fails "Module#private returns self"
@@ -67,8 +68,8 @@ opal_filter "private" do
   fails "Module#private_method_defined? raises a TypeError if passed nil"
   fails "Module#private_method_defined? returns true if the named private method is defined by module or its ancestors"
   fails "Module#protected is a private method"
-  fails "Module#protected makes a public Object instance method protected in a new module"
   fails "Module#protected makes a public Object instance method protected in Kernel"
+  fails "Module#protected makes a public Object instance method protected in a new module"
   fails "Module#protected makes an existing class method protected"
   fails "Module#protected raises a NameError when given an undefined name"
   fails "Module#protected returns self"
@@ -96,8 +97,8 @@ opal_filter "private" do
   fails "Module#protected_method_defined? raises a TypeError if passed nil"
   fails "Module#protected_method_defined? returns true if the named protected method is defined by module or its ancestors"
   fails "Module#public is a private method"
-  fails "Module#public makes a private Object instance method public in a new module"
   fails "Module#public makes a private Object instance method public in Kernel"
+  fails "Module#public makes a private Object instance method public in a new module"
   fails "Module#public raises a NameError when given an undefined name"
   fails "Module#public returns self"
   fails "Module#public without arguments affects evaled method definitions when itself is outside the eval"
@@ -131,6 +132,6 @@ opal_filter "private" do
   fails "Module#remove_method is a private method"
   fails "Module#undef_method is a private method"
   fails "OpenStruct#initialize is private"
-  fails "OpenStruct#table is protected"
   fails "OpenStruct#new_ostruct_member is protected"
+  fails "OpenStruct#table is protected"
 end

data/spec/filters/unsupported/string.rb

@@ -233,6 +233,7 @@ opal_filter "String" do
   fails "String#insert with index, other raises an IndexError if the index is beyond string"
   fails "String#insert with index, other taints self if string to insert is tainted"
   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 \\x notation"
   fails "String#inspect taints the result if self is tainted"
   fails "String#inspect untrusts the result if self is untrusted"
   fails "String#lines does not care if the string is modified while substituting"
@@ -523,4 +524,13 @@ opal_filter "String" do
   fails "String.new returns a binary String"
   fails "String.new returns a fully-formed String"
   fails "String.new returns a new string given a string argument"
+  fails "Ruby character strings taints the result of interpolation when an interpolated value is tainted"
+  fails "Ruby character strings untrusts the result of interpolation when an interpolated value is untrusted"
+  fails "Ruby character strings backslashes follow the same rules as interpolation"
+  fails "Ruby character strings are produced from control character shortcuts"
+  fails "Ruby character strings Unicode escaping can be done with \\u{} and one to six hex digits"
+  fails "Ruby character strings Unicode escaping with US-ASCII source encoding produces an ASCII string when escaping ASCII characters via \\u"
+  fails "Ruby character strings Unicode escaping with US-ASCII source encoding produces an ASCII string when escaping ASCII characters via \\u{}"
+  fails "Ruby character strings Unicode escaping with US-ASCII source encoding produces a UTF-8-encoded string when escaping non-ASCII characters via \\u"
+  fails "Ruby character strings Unicode escaping with US-ASCII source encoding produces a UTF-8-encoded string when escaping non-ASCII characters via \\u{}"
 end

data/spec/filters/unsupported/struct.rb

@@ -1,3 +1,6 @@
 opal_filter "Struct" do
   fails "Struct#initialize is private"
+  fails "Struct.new does not create a constant with symbol as first argument"
+  fails "Struct.new fails with invalid constant name as first argument" # this invalid name gets interpreted as a struct member
+  fails "Struct.new raises a TypeError if object is not a Symbol"
 end

data/spec/filters/unsupported/symbol.rb

@@ -1,5 +1,14 @@
 opal_filter "Symbol" do
   fails "Numeric#coerce raises a TypeError when passed a Symbol"
   fails "Fixnum#coerce raises a TypeError when given an Object that does not respond to #to_f"
+  fails "Symbol#to_proc produces a proc that always returns [[:rest]] for #parameters"
   fails "The throw keyword does not convert strings to a symbol"
+  fails "Module#const_get raises a NameError if a Symbol has a toplevel scope qualifier"
+  fails "Module#const_get raises a NameError if a Symbol is a scoped constant name"
+  fails "A Symbol literal is a ':' followed by any number of valid characters"
+  fails "A Symbol literal is a ':' followed by a single- or double-quoted string that may contain otherwise invalid characters"
+  fails "A Symbol literal is converted to a literal, unquoted representation if the symbol contains only valid characters"
+  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"
 end

data/spec/filters/unsupported/taint.rb

@@ -1,9 +1,6 @@
 opal_filter "taint" do
   fails "Hash#reject with extra state does not taint the resulting hash"
 
-  fails "Range#to_s ignores own tainted status"
-  fails "Range#inspect ignores own tainted status"
-
   fails "String#% doesn't taint the result for %e when argument is tainted"
   fails "String#% doesn't taint the result for %E when argument is tainted"
   fails "String#% doesn't taint the result for %f when argument is tainted"

data/spec/filters/unsupported/thread.rb

@@ -2,4 +2,5 @@ opal_filter "Thread" do
   fails "StandardError is a superclass of ThreadError"
   fails "The throw keyword raises an ArgumentError if used to exit a thread"
   fails "The throw keyword clears the current exception"
+  fails "Module#autoload loads the registered constant even if the constant was already loaded by another thread"
 end

data/spec/lib/cli_runners/phantomjs_spec.rb

@@ -0,0 +1,39 @@
+require 'lib/spec_helper'
+require 'opal/cli_runners/phantomjs'
+require 'stringio'
+
+describe Opal::CliRunners::Phantomjs do
+  # FIXME: Unfotunately there are some issues on jruby and 1.9.3, probably
+  #        related to IO.pipe and process spawning in general.
+  before { pending if RUBY_PLATFORM == 'java' or RUBY_VERSION == '1.9.3' }
+
+  it 'accepts arguments' do
+    expect(output_of(%{
+      var ARGV = JSON.parse(callPhantom(['argv']));
+      callPhantom(['stdout', JSON.stringify(ARGV)]);
+      callPhantom(['exit', 0]);
+    }, ['foo', 'bar'])).to eq('["foo","bar"]')
+  end
+
+  it 'sets env' do
+    ENV['FOO'] = 'BAR'
+    expect(output_of(%{
+      var ENV = JSON.parse(callPhantom(['env']));
+      callPhantom(['stdout', JSON.stringify(ENV)]);
+      callPhantom(['exit', 0]);
+    }, [])).to include(%{"FOO":"BAR"})
+  end
+
+
+  private
+
+  def output_of(*args)
+    read, write = IO.pipe
+    runner = described_class.new(output: write)
+
+    runner.run(*args)
+    write.close
+
+    return read.read
+  end
+end

data/spec/lib/cli_spec.rb

@@ -5,7 +5,7 @@ require 'stringio'
 describe Opal::CLI do
   let(:fake_stdout) { StringIO.new }
   let(:file)    { File.expand_path('../fixtures/opal_file.rb', __FILE__) }
-  let(:options) { nil }
+  let(:options) { {} }
   subject(:cli) { described_class.new(options) }
 
   context 'with a file' do
@@ -14,6 +14,14 @@ describe Opal::CLI do
     it 'runs the file' do
       expect_output_of{ subject.run }.to eq("hi from opal!\n")
     end
+
+    context 'with lib_only: true' do
+      let(:options) { super().merge lib_only: true }
+
+      it 'raises ArgumentError' do
+        expect{subject.run}.to raise_error(ArgumentError)
+      end
+    end
   end
 
   describe ':evals option' do
@@ -21,6 +29,14 @@ describe Opal::CLI do
       it 'raises ArgumentError' do
         expect { subject.run }.to raise_error(ArgumentError)
       end
+
+      context 'with lib_only: true' do
+        let(:options) { super().merge lib_only: true }
+
+        it 'does not raise an error' do
+          expect{subject.run}.not_to raise_error
+        end
+      end
     end
 
     context 'with one eval' do
@@ -29,6 +45,14 @@ describe Opal::CLI do
       it 'executes the code' do
         expect_output_of{ subject.run }.to eq("hello\n")
       end
+
+      context 'with lib_only: true' do
+        let(:options) { super().merge lib_only: true }
+
+        it 'raises ArgumentError' do
+          expect{subject.run}.to raise_error(ArgumentError)
+        end
+      end
     end
 
     context 'with many evals' do
@@ -56,6 +80,23 @@ describe Opal::CLI do
     end
   end
 
+  describe ':lib_only option' do
+    context 'when false' do
+      let(:options) { {lib_only: false, compile: true, evals: [''], skip_opal_require: true, no_exit: true} }
+      it 'appends an empty code block at the end of the source' do
+        expect_output_of{ subject.run }.to include("function(Opal)")
+      end
+    end
+
+    context 'when true' do
+      let(:options) { {lib_only: true, compile: true, skip_opal_require: true, no_exit: true} }
+
+      it 'does not append code block at the end of the source' do
+        expect_output_of{ subject.run }.to eq("\n")
+      end
+    end
+  end
+
   describe ':requires options' do
     context 'with an absolute path' do
       let(:options) { {:requires => [file], :evals => ['']} }

data/spec/lib/compiler/call_spec.rb

@@ -0,0 +1,700 @@
+require 'lib/spec_helper'
+
+describe Opal::Compiler do
+  let(:compiler) { Opal::Compiler.new(method) }
+
+  subject(:compiled) { compiler.compile }
+
+  describe 'defined' do
+    let(:method) do
+      <<-CODE
+      def some_method
+        defined? super()
+      end
+      CODE
+    end
+
+    context 'outside block' do
+      context 'method missing on' do
+        it { is_expected.to include "return (!(Opal.find_super_dispatcher(self, 'some_method', TMP_1, true).$$stub) ? \"super\" : nil);" }
+      end
+
+      context 'method missing off' do
+        let(:compiler) { Opal::Compiler.new(method, method_missing: false) }
+
+        it { is_expected.to include "return ((Opal.find_super_dispatcher(self, 'some_method', TMP_1, true)) != null ? \"super\" : nil);" }
+      end
+    end
+
+    context 'inside block' do
+      context 'implicit' do
+        let(:method) { 'lambda { defined? super }' }
+
+        it { is_expected.to include "return (!(Opal.find_iter_super_dispatcher(self, null, (TMP_1.$$def || null), true, false).$$stub) ? \"super\" : nil)}, TMP_1.$$s = self, TMP_1), $a).call($b)" }
+      end
+
+      context 'explicit' do
+        let(:method) { 'lambda { defined? super() }' }
+
+        it { is_expected.to include "return (!(Opal.find_iter_super_dispatcher(self, null, (TMP_1.$$def || null), true, false).$$stub) ? \"super\" : nil)}, TMP_1.$$s = self, TMP_1), $a).call($b)" }
+      end
+    end
+  end
+
+  describe 'call' do
+    context 'regular method' do
+      context 'formal parameters with splat' do
+        context 'and block with actual params of' do
+          let(:method) do
+            <<-CODE
+            def some_method(*stuff, &block2)
+              #{invocation}
+            end
+            CODE
+          end
+
+          context 'splat' do
+            context 'with block' do
+              context 'via variable' do
+                let(:invocation) { 'call_method(*stuff) {|a| foobar }' }
+
+                it do
+                  is_expected.to include <<-CODE
+    return ($b = ($c = self).$call_method, $b.$$p = (TMP_2 = function(a){var self = TMP_2.$$s || this;
+if (a == null) a = nil;
+    return self.$foobar()}, TMP_2.$$s = self, TMP_2), $b).apply($c, Opal.to_a(stuff));
+                  CODE
+                end
+              end
+
+              context 'via reference' do
+                let(:invocation) { 'call_method *stuff, &block2' }
+
+                it { is_expected.to include "return ($b = ($c = self).$call_method, $b.$$p = block2.$to_proc(), $b).apply($c, Opal.to_a(stuff));" }
+              end
+            end
+          end
+
+          context 'no splat' do
+            context 'with block' do
+              context 'via variable' do
+                let(:invocation) { 'call_method {|a| foobar }' }
+
+                it do
+                  is_expected.to include <<-CODE
+    return ($b = ($c = self).$call_method, $b.$$p = (TMP_2 = function(a){var self = TMP_2.$$s || this;
+if (a == null) a = nil;
+    return self.$foobar()}, TMP_2.$$s = self, TMP_2), $b).call($c);
+                  CODE
+                end
+              end
+
+              context 'via reference' do
+                let(:invocation) { 'call_method &block2' }
+
+                it { is_expected.to include "return ($b = ($c = self).$call_method, $b.$$p = block2.$to_proc(), $b).call($c);" }
+              end
+            end
+          end
+        end
+
+        context 'actual params of' do
+          let(:method) do
+            <<-CODE
+            def some_method(*stuff)
+              #{invocation}
+            end
+            CODE
+          end
+
+          context 'splat' do
+            context 'with block' do
+              context 'via variable' do
+                let(:invocation) { 'call_method(*stuff) {|a| foobar }' }
+
+                it do
+                  is_expected.to include <<-CODE
+    return ($b = ($c = self).$call_method, $b.$$p = (TMP_1 = function(a){var self = TMP_1.$$s || this;
+if (a == null) a = nil;
+    return self.$foobar()}, TMP_1.$$s = self, TMP_1), $b).apply($c, Opal.to_a(stuff));
+                  CODE
+                end
+              end
+
+              context 'via reference' do
+                let(:invocation) { 'call_method *stuff, &block2' }
+
+                it { is_expected.to include "return ($b = ($c = self).$call_method, $b.$$p = self.$block2().$to_proc(), $b).apply($c, Opal.to_a(stuff));" }
+              end
+            end
+          end
+
+          context 'no splat' do
+            context 'with block' do
+              context 'via variable' do
+                let(:invocation) { 'call_method {|a| foobar }' }
+
+                it do
+                  is_expected.to include <<-CODE
+    return ($b = ($c = self).$call_method, $b.$$p = (TMP_1 = function(a){var self = TMP_1.$$s || this;
+if (a == null) a = nil;
+    return self.$foobar()}, TMP_1.$$s = self, TMP_1), $b).call($c);
+                  CODE
+                end
+              end
+
+              context 'via reference' do
+                let(:invocation) { 'call_method &block2' }
+
+                it { is_expected.to include "return ($b = ($c = self).$call_method, $b.$$p = self.$block2().$to_proc(), $b).call($c);" }
+              end
+            end
+          end
+        end
+      end
+
+      context 'no formal parameters with actual params of' do
+        let(:method) do
+          <<-CODE
+          def regular_method
+            #{invocation}
+          end
+          CODE
+        end
+
+        context 'no splat' do
+          let(:invocation) { 'another_method(42)' }
+
+          it { is_expected.to include 'return self.$another_method(42);' }
+        end
+
+        context 'splat' do
+          context 'with no block' do
+            let(:invocation) { 'another_method(*args)' }
+
+            it { is_expected.to include 'return ($a = self).$another_method.apply($a, Opal.to_a(self.$args()));' }
+          end
+
+          context 'with block' do
+            context 'via variable' do
+              let(:invocation) { 'another_method(*args) {|b| foobar }' }
+
+              it { is_expected.to include "return ($a = ($b = self).$another_method, $a.$$p = (TMP_1 = function(b){var self = TMP_1.$$s || this;\nif (b == null) b = nil;\n    return self.$foobar()}, TMP_1.$$s = self, TMP_1), $a).apply($b, Opal.to_a(self.$args()));" }
+            end
+
+            context 'via reference' do
+              let(:invocation) { 'another_method(*args, &block2)' }
+
+              it { is_expected.to include "return ($a = ($b = self).$another_method, $a.$$p = self.$block2().$to_proc(), $a).apply($b, Opal.to_a(self.$args()));" }
+            end
+          end
+        end
+
+        context 'block' do
+          context 'via variable' do
+            let(:invocation) { 'another_method {|b| foobar }' }
+
+            it { is_expected.to include "return ($a = ($b = self).$another_method, $a.$$p = (TMP_1 = function(b){var self = TMP_1.$$s || this;\nif (b == null) b = nil;\n    return self.$foobar()}, TMP_1.$$s = self, TMP_1), $a).call($b);" }
+          end
+
+          context 'via reference' do
+            let(:invocation) { 'another_method(&block)' }
+
+            it { is_expected.to include 'return ($a = ($b = self).$another_method, $a.$$p = self.$block().$to_proc(), $a).call($b);' }
+          end
+        end
+      end
+    end
+
+    context 'super' do
+      context 'normal method' do
+        context 'formal parameters' do
+          context 'without splat' do
+            let(:method) do
+              <<-CODE
+              class Foobar
+                def some_method(foo, bar)
+                  #{invocation}
+                end
+              end
+              CODE
+            end
+
+            context 'no arguments' do
+              let(:invocation) { 'super()' }
+
+              it { is_expected.to include "return ($a = ($b = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $a.$$p = null, $a).call($b);" }
+            end
+
+            context 'implicit arguments' do
+              let(:invocation) { 'super' }
+
+              context 'no block' do
+                it { is_expected.to include "return ($a = ($b = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $a.$$p = $iter, $a).apply($b, $zuper);" }
+              end
+
+              context 'block' do
+                let(:method) do
+                  <<-CODE
+                  class Foobar
+                    def some_method(foo, &bar)
+                      #{invocation}
+                    end
+                  end
+                  CODE
+                end
+
+                it { is_expected.to include "return ($a = ($b = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $a.$$p = $iter, $a).apply($b, $zuper);" }
+              end
+            end
+          end
+
+          context 'with splat' do
+            context 'and block with actual params of' do
+              let(:method) do
+                <<-CODE
+                class Foobar
+                  def some_method(*stuff, &block2)
+                    #{invocation}
+                  end
+                end
+                CODE
+              end
+
+              context 'splat' do
+                context 'with block' do
+                  context 'via variable' do
+                    let(:invocation) { 'super(*stuff) {|a| foobar }' }
+
+                    it do
+                      is_expected.to include <<-CODE
+    return ($b = ($c = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $b.$$p = (TMP_2 = function(a){var self = TMP_2.$$s || this;
+if (a == null) a = nil;
+      return self.$foobar()}, TMP_2.$$s = self, TMP_2), $b).apply($c, Opal.to_a(stuff));
+                      CODE
+                    end
+                  end
+
+                  context 'via reference' do
+                    let(:invocation) { 'super *stuff, &block2' }
+
+                    it { is_expected.to include "return ($b = ($c = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $b.$$p = block2.$to_proc(), $b).apply($c, Opal.to_a(stuff));" }
+                  end
+                end
+              end
+
+              context 'no splat' do
+                context 'with block' do
+                  context 'via variable' do
+                    let(:invocation) { 'super {|a| foobar }' }
+
+                    it do
+                      is_expected.to include <<-CODE
+    return ($b = ($c = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $b.$$p = (TMP_2 = function(a){var self = TMP_2.$$s || this;
+if (a == null) a = nil;
+      return self.$foobar()}, TMP_2.$$s = self, TMP_2), $b).apply($c, $zuper);
+                      CODE
+                    end
+                  end
+
+                  context 'via reference' do
+                    let(:invocation) { 'super &block2' }
+
+                    it { is_expected.to include "return ($b = ($c = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $b.$$p = block2.$to_proc(), $b).call($c);" }
+                  end
+                end
+              end
+
+              context 'no arguments' do
+                let(:invocation) { 'super()' }
+
+                it { is_expected.to include "return ($b = ($c = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $b.$$p = null, $b).call($c);" }
+              end
+            end
+
+            context 'actual params of' do
+              let(:method) do
+                <<-CODE
+                class Foobar
+                  def some_method(*stuff)
+                    #{invocation}
+                  end
+                end
+                CODE
+              end
+
+              context 'splat' do
+                context 'with block' do
+                  context 'via variable' do
+                    let(:invocation) { 'super(*stuff) {|a| foobar }' }
+
+                    it do
+                      is_expected.to include <<-CODE
+      return ($b = ($c = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $b.$$p = (TMP_2 = function(a){var self = TMP_2.$$s || this;
+if (a == null) a = nil;
+      return self.$foobar()}, TMP_2.$$s = self, TMP_2), $b).apply($c, Opal.to_a(stuff));
+                      CODE
+                    end
+                  end
+
+                  context 'via reference' do
+                    let(:invocation) { 'super *stuff, &block2' }
+
+                    it { is_expected.to include "return ($b = ($c = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $b.$$p = self.$block2().$to_proc(), $b).apply($c, Opal.to_a(stuff));" }
+                  end
+                end
+              end
+
+              context 'no splat' do
+                context 'with block' do
+                  context 'via variable' do
+                    let(:invocation) { 'super {|a| foobar }' }
+
+                    it do
+                      is_expected.to include <<-CODE
+      return ($b = ($c = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $b.$$p = (TMP_2 = function(a){var self = TMP_2.$$s || this;
+if (a == null) a = nil;
+      return self.$foobar()}, TMP_2.$$s = self, TMP_2), $b).apply($c, $zuper);
+      CODE
+                    end
+                  end
+
+                  context 'via reference' do
+                    let(:invocation) { 'super &block2' }
+
+                    it { is_expected.to include "return ($b = ($c = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $b.$$p = self.$block2().$to_proc(), $b).call($c);" }
+                  end
+                end
+              end
+
+              context 'no arguments' do
+                let(:invocation) { 'super()' }
+
+                it { is_expected.to include "return ($b = ($c = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false)), $b.$$p = null, $b).call($c);" }
+              end
+            end
+          end
+        end
+
+        context 'no formal parameters with actual params of' do
+          let(:method) do
+            <<-CODE
+            class Foobar
+              def regular_method
+                #{invocation}
+              end
+            end
+            CODE
+          end
+
+          context 'no splat' do
+            let(:invocation) { 'super(42)' }
+
+            it { is_expected.to include "return ($a = ($b = self, Opal.find_super_dispatcher(self, 'regular_method', TMP_1, false)), $a.$$p = null, $a).call($b, 42);" }
+          end
+
+          context 'splat' do
+            context 'with no block' do
+              let(:invocation) { "args=[1,2,3]\nsuper(*args)" }
+
+              it { is_expected.to include "return ($a = ($b = self, Opal.find_super_dispatcher(self, 'regular_method', TMP_1, false)), $a.$$p = null, $a).apply($b, Opal.to_a(args));" }
+            end
+
+            context 'with block' do
+              context 'via variable' do
+                let(:invocation) { 'super(*args) {|b| foobar }' }
+
+                it do
+                  is_expected.to include <<-CODE
+      return ($a = ($b = self, Opal.find_super_dispatcher(self, 'regular_method', TMP_1, false)), $a.$$p = (TMP_2 = function(b){var self = TMP_2.$$s || this;
+if (b == null) b = nil;
+      return self.$foobar()}, TMP_2.$$s = self, TMP_2), $a).apply($b, Opal.to_a(self.$args()));
+                  CODE
+                end
+              end
+
+              context 'via reference' do
+                let(:invocation) { 'super(*args, &block2)' }
+
+                it { is_expected.to include "return ($a = ($b = self, Opal.find_super_dispatcher(self, 'regular_method', TMP_1, false)), $a.$$p = self.$block2().$to_proc(), $a).apply($b, Opal.to_a(self.$args()));" }
+              end
+            end
+          end
+
+          context 'block' do
+            context 'via variable' do
+              let(:invocation) { 'super {|b| foobar }' }
+
+              it do
+                is_expected.to include <<-CODE
+      return ($a = ($b = self, Opal.find_super_dispatcher(self, 'regular_method', TMP_1, false)), $a.$$p = (TMP_2 = function(b){var self = TMP_2.$$s || this;
+if (b == null) b = nil;
+      return self.$foobar()}, TMP_2.$$s = self, TMP_2), $a).apply($b, $zuper);
+                CODE
+              end
+            end
+
+            context 'via reference' do
+              let(:invocation) { 'super(&block)' }
+
+              it { is_expected.to include "return ($a = ($b = self, Opal.find_super_dispatcher(self, 'regular_method', TMP_1, false)), $a.$$p = self.$block().$to_proc(), $a).call($b);" }
+            end
+          end
+
+          context 'no arguments' do
+            let(:invocation) { 'super()' }
+
+            it { is_expected.to include "return ($a = ($b = self, Opal.find_super_dispatcher(self, 'regular_method', TMP_1, false)), $a.$$p = null, $a).call($b);" }
+          end
+        end
+      end
+
+      context 'block' do
+        let(:method) { 'stuff = lambda { super }'}
+
+        it { is_expected.to include "return ($c = ($d = self, Opal.find_iter_super_dispatcher(self, null, (TMP_1.$$def || null), false, true)), $c.$$p = $iter, $c).apply($d)}, TMP_1.$$s = self, TMP_1), $a).call($b)" }
+      end
+
+      context 'block inside method' do
+        context 'first node' do
+          let(:method) do
+            <<-CODE
+            def in_method
+              foo { super }
+            end
+            CODE
+          end
+
+          it { is_expected.to include "return ($c = ($d = self, Opal.find_iter_super_dispatcher(self, 'in_method', (TMP_1.$$def || TMP_2), false, true)), $c.$$p = $iter, $c).apply($d, $zuper)}, TMP_1.$$s = self, TMP_1), $a).call($b);" }
+        end
+
+        context 'not first node' do
+          let(:method) do
+            <<-CODE
+            module Foo
+              def foo
+                foobar
+                fetch { return super }
+              end
+            end
+            CODE
+          end
+
+          it { is_expected.to include "Opal.ret(($c = ($d = self, Opal.find_iter_super_dispatcher(self, 'foo', (TMP_1.$$def || TMP_2), false, true)), $c.$$p = $iter, $c).apply($d, $zuper))}, TMP_1.$$s = self, TMP_1), $a).call($b);" }
+        end
+
+        context 'right method is called, IS THIS A NEW CASE??' do
+          let(:method) do
+            <<-CODE
+            class Bar
+              def m
+                :abc
+              end
+            end
+
+            class Foo < Bar
+              def self.do_defining(name, &body)
+                define_method(name, &body)
+              end
+
+              def self.setup
+                do_defining(:m) { |*args| super(*args) }
+              end
+            end
+            CODE
+          end
+
+          # runtime if (current_func.$$def) code should take care of locating the correct method here
+          it { is_expected.to include "return ($d = ($e = self, Opal.find_iter_super_dispatcher(self, 'setup', (TMP_2.$$def || TMP_3), false, false)), $d.$$p = null, $d).apply($e, Opal.to_a(args))}, TMP_2.$$s = self, TMP_2), $a).call($b, \"m\");" }
+        end
+      end
+
+      context 'define_method' do
+        let(:method) do
+          <<-CODE
+          class Foobar
+            #{invocation}
+          end
+          CODE
+        end
+
+        context 'implicit' do
+          let(:invocation) { 'define_method(:wilma) { super }' }
+
+          it { is_expected.to include "return ($c = ($d = self, Opal.find_iter_super_dispatcher(self, null, (TMP_1.$$def || null), false, true)), $c.$$p = $iter, $c).apply($d)}, TMP_1.$$s = self, TMP_1), $a).call($b, \"wilma\")" }
+        end
+
+        context 'module' do
+          let(:method) do
+            <<-CODE
+            module Foobar
+              define_method(:wilma) { super() }
+            end
+            CODE
+          end
+
+          it do
+            is_expected.to include <<-CODE
+    ($a = ($b = self).$define_method, $a.$$p = (TMP_1 = function(){var self = TMP_1.$$s || this, $c, $d;
+
+    return ($c = ($d = self, Opal.find_iter_super_dispatcher(self, null, (TMP_1.$$def || null), false, false)), $c.$$p = null, $c).call($d)}, TMP_1.$$s = self, TMP_1), $a).call($b, "wilma")
+            CODE
+          end
+        end
+
+        context 'anonymous class' do
+          context 'not nested, only item in class' do
+            let(:method) do
+              <<-CODE
+              Class.new do
+                define_method :foo do
+                  super()
+                end
+              end
+              CODE
+            end
+
+            it { is_expected.to include "return ($e = ($f = self, Opal.find_iter_super_dispatcher(self, null, (TMP_2.$$def || TMP_1.$$def || null), false, false)), $e.$$p = null, $e).call($f)}, TMP_2.$$s = self, TMP_2), $c).call($d, \"foo\")}, TMP_1.$$s = self, TMP_1), $a).call($b)" }
+          end
+
+          context 'alongside def''d method' do
+            let(:method) do
+              <<-CODE
+              sup = Class.new do
+                def a
+                  :abc
+                end
+              end
+
+              Class.new(sup) do
+                def fetch(&block)
+                  block.call
+                end
+
+                define_method(:a) { fetch { super(&nil)} }
+              end
+              CODE
+            end
+
+            it { is_expected.to include "return ($h = ($i = self, Opal.find_iter_super_dispatcher(self, null, (TMP_5.$$def || TMP_4.$$def || TMP_2.$$def || null), false, false)), $h.$$p = nil.$to_proc(), $h).call($i)}, TMP_5.$$s = self, TMP_5), $f).call($g)}, TMP_4.$$s = self, TMP_4), $d).call($e, \"a\");}, TMP_2.$$s = self, TMP_2), $a).call($c, sup);" }
+          end
+
+          context 'alongside another define_method' do
+            let(:method) do
+              <<-CODE
+              sup = Class.new do
+                def a
+                  :abc
+                end
+              end
+
+              Class.new(sup) do
+                define_method(:fetch) do |&block|
+                  block.call
+                end
+
+                define_method(:a) { fetch { super(&nil)} }
+              end
+              CODE
+            end
+
+            it { is_expected.to include "return ($i = ($j = self, Opal.find_iter_super_dispatcher(self, null, (TMP_5.$$def || TMP_4.$$def || TMP_2.$$def || null), false, false)), $i.$$p = nil.$to_proc(), $i).call($j)}, TMP_5.$$s = self, TMP_5), $g).call($h)}, TMP_4.$$s = self, TMP_4), $d).call($f, \"a\");}, TMP_2.$$s = self, TMP_2), $a).call($c, sup);" }
+          end
+
+          context 'not last method in class' do
+            let(:method) do
+              <<-CODE
+              sup = Class.new do
+                def a
+                  :abc
+                end
+              end
+
+              Class.new(sup) do
+                define_method(:a) { fetch { super(&nil)} }
+
+                def fetch(&block)
+                  block.call
+                end
+              end
+              CODE
+            end
+
+            it { is_expected.to include "return ($h = ($i = self, Opal.find_iter_super_dispatcher(self, null, (TMP_4.$$def || TMP_3.$$def || TMP_2.$$def || null), false, false)), $h.$$p = nil.$to_proc(), $h).call($i)}, TMP_4.$$s = self, TMP_4), $f).call($g)}, TMP_3.$$s = self, TMP_3), $d).call($e, \"a\");" }
+          end
+        end
+
+        context 'inside a method' do
+          let(:method) do
+            <<-CODE
+            module Bar
+              def fetch
+              end
+
+              def foo
+                some_call
+
+                if some_arg
+                  block2 = lambda { the_block }
+                  define_method(:a) { fetch { super(some_arg, &block2)} }
+                else
+                  define_method(:a) { fetch { super(&nil)} }
+                end
+              end
+            end
+            CODE
+          end
+
+          it { is_expected.to include "return ($f = ($g = self, Opal.find_iter_super_dispatcher(self, 'foo', (TMP_3.$$def || TMP_2.$$def || TMP_4), false, false)), $f.$$p = block2.$to_proc(), $f).call($g, self.$some_arg())}, TMP_3.$$s = self, TMP_3), $d).call($e)}, TMP_2.$$s = self, TMP_2), $a).call($c, \"a\");" }
+          it { is_expected.to include "return ($g = ($h = self, Opal.find_iter_super_dispatcher(self, 'foo', (TMP_6.$$def || TMP_5.$$def || TMP_4), false, false)), $g.$$p = nil.$to_proc(), $g).call($h)}, TMP_6.$$s = self, TMP_6), $e).call($f)}, TMP_5.$$s = self, TMP_5), $a).call($d, \"a\")" }
+        end
+
+        context 'explicit' do
+          let(:invocation) { 'define_method(:wilma) { super() }' }
+
+          it do
+            is_expected.to include <<-CODE
+    return ($a = ($b = self).$define_method, $a.$$p = (TMP_1 = function(){var self = TMP_1.$$s || this, $c, $d;
+
+    return ($c = ($d = self, Opal.find_iter_super_dispatcher(self, null, (TMP_1.$$def || null), false, false)), $c.$$p = null, $c).call($d)}, TMP_1.$$s = self, TMP_1), $a).call($b, "wilma")
+            CODE
+          end
+        end
+
+        context 'invalid case alongside other valid super cases' do
+          let(:method) do
+            <<-CODE
+            Class.new do
+              define_method(:foo) { super }
+
+              Class.new(c1) do
+                def m
+                  other_method { super }
+                end
+              end
+            end
+            CODE
+          end
+
+          it { is_expected.to include "return ($e = ($f = self, Opal.find_iter_super_dispatcher(self, null, (TMP_2.$$def || TMP_1.$$def || null), false, true)), $e.$$p = $iter, $e).apply($f)}, TMP_2.$$s = self, TMP_2), $c).call($d, \"foo\");" }
+
+          it { is_expected.to include "return ($c = ($d = self, Opal.find_iter_super_dispatcher(self, 'm', (TMP_5.$$def || TMP_6), false, true)), $c.$$p = $iter, $c).apply($d, $zuper)}, TMP_5.$$s = self, TMP_5), $a).call($b);" }
+        end
+      end
+
+      context 'singleton' do
+        let(:method) do
+          <<-CODE
+          class Foobar
+            def self.some_method
+              super
+            end
+          end
+          CODE
+        end
+
+        it { is_expected.to include "return ($a = ($b = self, Opal.find_super_dispatcher(self, 'some_method', TMP_1, false, $Foobar)), $a.$$p = $iter, $a).apply($b, $zuper);" }
+      end
+    end
+  end
+end