opal 0.3.41 → 0.3.42

data/spec/language/fixtures/send_1.9.rb

@@ -0,0 +1,22 @@
+module LangSendSpecs
+  # module_function
+
+  def self.fooR(*r); r; end
+  # def self.fooM0RQ1(*r, q); [r, q]; end
+  # def self.fooM0RQ2(*r, s, q); [r, s, q]; end
+  # def self.fooM1RQ1(a, *r, q); [a, r, q]; end
+  # def self.fooM1O1RQ1(a, b=9, *r, q); [a, b, r, q]; end
+  # def self.fooM1O1RQ2(a, b=9, *r, q, t); [a, b, r, q, t]; end
+
+  # def self.fooO1Q1(a=1, b); [a,b]; end
+  # def self.fooM1O1Q1(a,b=2,c); [a,b,c]; end
+  # def self.fooM2O1Q1(a,b,c=3,d); [a,b,c,d]; end
+  # def self.fooM2O2Q1(a,b,c=3,d=4,e); [a,b,c,d,e]; end
+  # def self.fooO4Q1(a=1,b=2,c=3,d=4,e); [a,b,c,d,e]; end
+  # def self.fooO4Q2(a=1,b=2,c=3,d=4,e,f); [a,b,c,d,e,f]; end
+
+  # def self.destructure2((a,b)); a+b; end
+  # def self.destructure2b((a,b)); [a,b]; end
+  # def self.destructure4r((a,b,*c,d,e)); [a,b,c,d,e]; end
+
+end

data/spec/language/fixtures/super.rb

@@ -0,0 +1,308 @@
+module Super
+  module S1
+    class A
+      def foo(a)
+        a << "A#foo"
+        bar(a)
+      end
+      def bar(a)
+        a << "A#bar"
+      end
+    end
+    class B < A
+      def foo(a)
+        a << "B#foo"
+        super(a)
+      end
+      def bar(a)
+        a << "B#bar"
+        super(a)
+      end
+    end
+  end
+
+  module S2
+    class A
+      def baz(a)
+        a << "A#baz"
+      end
+    end
+    class B < A
+      def foo(a)
+        a << "B#foo"
+        baz(a)
+      end
+    end
+    class C < B
+      def baz(a)
+        a << "C#baz"
+        super(a)
+      end
+    end
+  end
+
+  module S3
+    class A
+      def foo(a)
+        a << "A#foo"
+      end
+      def self.foo(a)
+        a << "A::foo"
+      end
+      def self.bar(a)
+        a << "A::bar"
+        foo(a)
+      end
+    end
+    class B < A
+      def self.foo(a)
+        a << "B::foo"
+        super(a)
+      end
+      def self.bar(a)
+        a << "B::bar"
+        super(a)
+      end
+    end
+  end
+
+  module S4
+    class A
+      def foo(a)
+        a << "A#foo"
+      end
+    end
+    class B < A
+      def foo(a, b)
+        a << "B#foo(a,#{b})"
+        super(a)
+      end
+    end
+  end
+
+  class S5
+    def here
+      :good
+    end
+  end
+
+  class S6 < S5
+    def under
+      yield
+    end
+
+    def here
+      under {
+        super
+      }
+    end
+  end
+
+  class S7 < S5
+    define_method(:here) { super() }
+  end
+
+  module MS1
+    module ModA
+      def foo(a)
+        a << "ModA#foo"
+        bar(a)
+      end
+      def bar(a)
+        a << "ModA#bar"
+      end
+    end
+    class A
+      include ModA
+    end
+    module ModB
+      def bar(a)
+        a << "ModB#bar"
+        super(a)
+      end
+    end
+    class B < A
+      def foo(a)
+        a << "B#foo"
+        super(a)
+      end
+      include ModB
+    end
+  end
+
+  module MS2
+    class A
+      def baz(a)
+        a << "A#baz"
+      end
+    end
+    module ModB
+      def foo(a)
+        a << "ModB#foo"
+        baz(a)
+      end
+    end
+    class B < A
+      include ModB
+    end
+    class C < B
+      def baz(a)
+        a << "C#baz"
+        super(a)
+      end
+    end
+  end
+
+  module MS3
+    module ModA
+      def foo(a)
+        a << "ModA#foo"
+      end
+      def bar(a)
+        a << "ModA#bar"
+        foo(a)
+      end
+    end
+    class A
+      def foo(a)
+        a << "A#foo"
+      end
+      class << self
+        #include ModA
+      end
+    end
+    class B < A
+      def self.foo(a)
+        a << "B::foo"
+        super(a)
+      end
+      def self.bar(a)
+        a << "B::bar"
+        super(a)
+      end
+    end
+  end
+
+  module MS4
+    module Layer1
+      def example
+        5
+      end
+    end
+
+    module Layer2
+      include Layer1
+      def example
+        super
+      end
+    end
+
+    class A
+      include Layer2
+      public :example
+    end
+  end
+
+  class MM_A
+    undef_method :is_a?
+  end
+
+  class MM_B < MM_A
+    def is_a?(blah)
+      # should fire the method_missing below
+      super
+    end
+
+    def method_missing(*)
+      false
+    end
+  end
+
+  class Alias1
+    def name
+      [:alias1]
+    end
+  end
+
+  class Alias2 < Alias1
+    def initialize
+      @times = 0
+    end
+
+    def name
+      if @times >= 10
+        raise "runaway super"
+      end
+
+      @times += 1
+
+      # Use this so that we can see collect all supers that we see.
+      # One bug that arises is that we call Alias2#name from Alias2#name
+      # as it's superclass. In that case, either we get a runaway recursion
+      # super OR we get the return value being [:alias2, :alias2, :alias1]
+      # rather than [:alias2, :alias1].
+      #
+      # Which one depends on caches and how super is implemented.
+      [:alias2] + super
+    end
+  end
+
+  class Alias3 < Alias2
+    alias_method :name3, :name
+    # In the method table for Alias3 now should be a special alias entry
+    # that references Alias2 and Alias2#name (probably as an object).
+    #
+    # When name3 is called then, Alias2 (NOT Alias3) is presented as the
+    # current module to Alias2#name, so that when super is called,
+    # Alias2->superclass is next.
+    #
+    # Otherwise, Alias2 is next, which is where name was to begin with,
+    # causing the wrong #name method to be called.
+  end
+
+  module AliasWithSuper
+    module AS1
+      def foo
+        :a
+      end
+    end
+
+    module BS1
+      def foo
+        [:b, super]
+      end
+    end
+
+    class Base
+      extend AS1
+      extend BS1
+    end
+
+    class Trigger < Base
+      class << self
+        def foo_quux
+          foo_baz
+        end
+
+        alias_method :foo_baz, :foo
+        alias_method :foo, :foo_quux
+      end
+    end
+  end
+
+  module RestArgsWithSuper
+    class A
+      def a(*args)
+        args
+      end
+    end
+
+    class B < A
+      def a(*args)
+        args << "foo"
+
+        super
+      end
+    end
+  end
+end

data/spec/language/fixtures/variables.rb

@@ -0,0 +1,58 @@
+module VariablesSpecs
+  class ParAsgn
+    attr_accessor :x
+
+    def initialize
+      @x = 0
+    end
+
+    def inc
+      @x += 1
+    end
+
+    def to_ary
+      [1,2,3,4]
+    end
+  end
+
+  class OpAsgn
+    attr_accessor :a, :b, :side_effect
+
+    def do_side_effect
+      self.side_effect = true
+      return @a
+    end
+
+    def do_more_side_effects
+      @a += 5
+      self
+    end
+
+    def do_bool_side_effects
+      @b += 1
+      self
+    end
+  end
+
+  class Hashalike
+    def [](k) k end
+    def []=(k, v) [k, v] end
+  end
+
+  def self.reverse_foo(a, b)
+    return b, a
+  end
+
+  class ArrayLike
+    def initialize(array)
+      @array = array
+    end
+
+    def to_a
+      @array
+    end
+  end
+
+  class ArraySubclass < Array
+  end
+end

data/spec/language/fixtures/yield.rb

@@ -4,6 +4,11 @@ module YieldSpecs
       yield
     end
 
+    def ze(&block)
+      block = proc { block }
+      yield
+    end
+
     def s(a)
       yield(a)
     end

data/spec/language/for_spec.rb

@@ -0,0 +1,192 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+# for name[, name]... in expr [do]
+#   body
+# end
+describe "The for expression" do
+  pending "iterates over an Enumerable passing each element to the block" do
+    # j = 0
+    # for i in 1..3
+    #   j += i
+    # end
+    # j.should == 6
+  end
+
+  pending "iterates over an Hash passing each key-value pair to the block" do
+    # k = 0
+    # l = 0
+
+    # for i, j in { 1 => 10, 2 => 20 }
+    #   k += i
+    #   l += j
+    # end
+
+    # k.should == 3
+    # l.should == 30
+  end
+
+  pending "iterates over any object responding to 'each'" do
+    # class XYZ
+    #   def each
+    #     (0..10).each { |i| yield i }
+    #   end
+    # end
+
+    # j = 0
+    # for i in XYZ.new
+    #   j += i
+    # end
+    # j.should == 55
+  end
+
+  pending "allows an instance variable as an iterator name" do
+    # m = [1,2,3]
+    # n = 0
+    # for @var in m
+    #   n += 1
+    # end
+    # @var.should == 3
+    # n.should == 3
+  end
+
+  pending "allows a class variable as an iterator name" do
+    # class OFor
+    #   m = [1,2,3]
+    #   n = 0
+    #   for @@var in m
+    #     n += 1
+    #   end
+    #   @@var.should == 3
+    #   n.should == 3
+    # end
+  end
+
+  pending "allows a constant as an iterator name" do
+    # class OFor
+    #   m = [1,2,3]
+    #   n = 0
+    #   for CONST in m
+    #     n += 1
+    #   end
+    #   CONST.should == 3
+    #   n.should == 3
+    # end
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "splats multiple arguments together if there are fewer arguments than values" do
+      # class OFor
+      #   def each
+      #     [[1,2,3], [4,5,6]].each do |a|
+      #       yield(a[0],a[1],a[2])
+      #     end
+      #   end
+      # end
+      # o = OFor.new
+      # qs = []
+      # for q in o
+      #   qs << q
+      # end
+      # qs.should == [[1,2,3], [4,5,6]]
+      # q.should == [4,5,6]
+    end
+  end
+
+  # 1.9 behaviour verified by nobu in
+  # http://redmine.ruby-lang.org/issues/show/2053
+  ruby_version_is "1.9" do
+    pending "yields only as many values as there are arguments" do
+      # class OFor
+      #   def each
+      #     [[1,2,3], [4,5,6]].each do |a|
+      #       yield(a[0],a[1],a[2])
+      #     end
+      #   end
+      # end
+      # o = OFor.new
+      # qs = []
+      # for q in o
+      #   qs << q
+      # end
+      # qs.should == [1, 4]
+      # q.should == 4
+    end
+  end
+
+  pending "optionally takes a 'do' after the expression" do
+    # j = 0
+    # for i in 1..3 do
+    #   j += i
+    # end
+    # j.should == 6
+  end
+
+  pending "allows body begin on the same line if do is used" do
+    # j = 0
+    # for i in 1..3 do j += i
+    # end
+    # j.should == 6
+  end
+
+  pending "executes code in containing variable scope" do
+    # for i in 1..2
+    #   a = 123
+    # end
+
+    # a.should == 123
+  end
+
+  pending "executes code in containing variable scope with 'do'" do
+    # for i in 1..2 do
+    #   a = 123
+    # end
+
+    # a.should == 123
+  end
+
+  pending "returns expr" do
+    # for i in 1..3; end.should == (1..3)
+    # for i,j in { 1 => 10, 2 => 20 }; end.should == { 1 => 10, 2 => 20 }
+  end
+
+  pending "breaks out of a loop upon 'break', returning nil" do
+    # j = 0
+    # for i in 1..3
+    #   j += i
+
+    #   break if i == 2
+    # end.should == nil
+
+    # j.should == 3
+  end
+
+  pending "allows 'break' to have an argument which becomes the value of the for expression" do
+    # for i in 1..3
+    #   break 10 if i == 2
+    # end.should == 10
+  end
+
+  pending "starts the next iteration with 'next'" do
+    # j = 0
+    # for i in 1..5
+    #   next if i == 2
+
+    #   j += i
+    # end
+
+    # j.should == 13
+  end
+
+  pending "repeats current iteration with 'redo'" do
+    # j = 0
+    # for i in 1..3
+    #   j += i
+
+    #   redo if i == 2 && j < 4
+    # end
+
+    # j.should == 8
+  end
+end
+
+# language_version __FILE__, "for"