opal 0.10.0 → 0.11.0

data/spec/opal/core/language/fixtures/send.rb

@@ -1,111 +0,0 @@
-module LangSendSpecs
-  # module_function
-
-  def self.fooM0; 100 end
-  def self.fooM1(a); [a]; end
-  def self.fooM2(a,b); [a,b]; end
-  def self.fooM3(a,b,c); [a,b,c]; end
-  def self.fooM4(a,b,c,d); [a,b,c,d]; end
-  def self.fooM5(a,b,c,d,e); [a,b,c,d,e]; end
-  def self.fooM0O1(a=1); [a]; end
-  def self.fooM1O1(a,b=1); [a,b]; end
-  def self.fooM2O1(a,b,c=1); [a,b,c]; end
-  def self.fooM3O1(a,b,c,d=1); [a,b,c,d]; end
-  def self.fooM4O1(a,b,c,d,e=1); [a,b,c,d,e]; end
-  def self.fooM0O2(a=1,b=2); [a,b]; end
-  def self.fooM0R(*r); r; end
-  def self.fooM1R(a, *r); [a, r]; end
-  def self.fooM0O1R(a=1, *r); [a, r]; end
-  def self.fooM1O1R(a, b=1, *r); [a, b, r]; end
-  def self.fooM1O2(a, b={}, &block); [a, b, block]; end
-
-  def self.one(a); a; end
-  def self.oneb(a,&b); [a,yield(b)]; end
-  # def twob(a,b,&c); [a,b,yield(c)]; end
-  def self.makeproc(&b) b end
-
-  # def yield_now; yield; end
-
-  def self.double(x); x * 2 end
-  def self.weird_parens
-    # means double((5).to_s)
-    # NOT   (double(5)).to_s
-    double (5).to_s
-  end
-
-  def self.rest_len(*a); a.size; end
-
-  def self.twos(a,b,*c)
-    [c.size, c.last]
-  end
-
-  class PrivateSetter
-    attr_reader :foo
-    attr_writer :foo
-    private :foo=
-
-      def call_self_foo_equals(value)
-        self.foo = value
-      end
-
-    def call_self_foo_equals_masgn(value)
-      a, self.foo = 1, value
-    end
-  end
-  
-  class PrivateGetter
-    attr_reader :foo
-    private :foo
-
-    def call_self_foo
-      self.foo
-    end
-
-    def call_self_foo_or_equals(value)
-      # self.foo ||= 6
-    end
-  end
-
-  class AttrSet
-    attr_reader :result
-    def []=(a, b, c, d); @result = [a,b,c,d]; end
-  end
-
-  class ToProc
-    def initialize(val)
-      @val = val
-    end
-
-    def to_proc
-      Proc.new { @val }
-    end
-  end
-
-  class ToAry
-    def initialize(obj)
-      @obj = obj
-    end
-
-    def to_ary
-      @obj
-    end
-  end
-
-  class MethodMissing
-    def initialize
-      @message = nil
-      @args = nil
-    end
-
-    attr_reader :message, :args
-
-    def method_missing(m, *a)
-      @message = m
-      @args = a
-    end
-  end
-end
-
-def lang_send_rest_len(*a)
-  a.size
-end

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

@@ -1,22 +0,0 @@
-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/opal/core/language/fixtures/super.rb

@@ -1,308 +0,0 @@
-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/opal/core/language/fixtures/variables.rb

@@ -1,58 +0,0 @@
-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/opal/core/language/fixtures/yield.rb

@@ -1,28 +0,0 @@
-module YieldSpecs
-  class Yielder
-    def z
-      yield
-    end
-
-    def ze(&block)
-      block = proc { block }
-      yield
-    end
-
-    def s(a)
-      yield(a)
-    end
-
-    def m(a, b, c)
-      yield(a, b, c)
-    end
-
-    def r(a)
-      yield(*a)
-    end
-
-    def rs(a, b, c)
-      yield(a, b, *c)
-    end
-  end
-end

data/spec/opal/core/language/heredoc_spec.rb

@@ -1,42 +0,0 @@
-describe "'Squiggly' heredoc" do
-  context "when heredoc is blank" do
-    it "returns a blank string" do
-      heredoc = <<~HERE
-      HERE
-
-      heredoc.should == ""
-    end
-  end
-
-  context "when heredoc contains multiple lines" do
-    it "selects a least-indented line and removes its indentation from all the lines" do
-      heredoc = <<~HERE
-        a
-          b
-           c
-      HERE
-
-      heredoc.should == "a\n  b\n   c\n"
-    end
-  end
-
-  it "supports escaped heredoc identifier" do
-    <<~"HERE".should == ""
-    HERE
-
-    <<~'HERE'.should == ""
-    HERE
-  end
-
-  it "doesn't allow <<-~ syntax" do
-    lambda {
-      eval("<<-~HERE\nHERE")
-    }.should raise_error
-  end
-
-  it "doesn't allow <<~- syntax" do
-    lambda {
-      eval("<<~-HERE\nHERE")
-    }.should raise_error
-  end
-end

data/spec/opal/core/language/keyword_arguments_spec.rb

@@ -1,11 +0,0 @@
-describe "Keyword arguments" do
-  def m a, b = nil, c: 123
-    [a, b, c]
-  end
-
-  it "def method_a(b, c=nil, d:nil)" do
-    m(1,2,c: 3).should == [1, 2, 3]
-    m(1, c: 3).should == [1, nil, 3]
-    m(1).should == [1, nil, 123]
-  end
-end

data/spec/opal/core/language/predefined_spec.rb

@@ -1,138 +0,0 @@
-describe "predefined global $~" do
-  it "is set to contain the MatchData object of the last match if successful" do
-    md = /foo/.match 'foo'
-    $~.should be_kind_of(MatchData)
-    $~.object_id.should == md.object_id
-
-    /bar/ =~ 'bar'
-    $~.should be_kind_of(MatchData)
-    $~.object_id.should_not == md.object_id
-  end
-
-  it "is set to nil if the last match was unsuccessful" do
-    /foo/ =~ 'foo'
-    $~.nil?.should == false
-
-    /foo/ =~ 'bar'
-    $~.nil?.should == true
-  end
-
-  it "changes the value of derived capture globals when assigned" do
-    "foo" =~ /(f)oo/
-    foo_match = $~
-    "bar" =~ /(b)ar/
-    $~ = foo_match
-    $1.should == "f"
-  end
-end
-
-describe "Predefined global match $&" do
-  it "is equivalent to MatchData#[0] on the last match $~" do
-    /foo/ =~ 'barfoobaz'
-    $&.should == $~[0]
-    $&.should == 'foo'
-  end
-end
-describe "Predefined global $`" do
-  it "is equivalent to MatchData#pre_match on the last match $~" do
-    /foo/ =~ 'barfoobaz'
-    $`.should == $~.pre_match
-    $`.should == 'bar'
-  end
-end
-
-describe "Predefined global $'" do
-  it "is equivalent to MatchData#post_match on the last match $~" do
-    /foo/ =~ 'barfoobaz'
-    $'.should == $~.post_match
-    $'.should == 'baz'
-  end
-end
-
-describe "predefined globals $1..N" do
-  it "are equivalent to $~[N]" do
-    /(f)(o)(o)/ =~ 'foo'
-    $1.should == $~[1]
-    $2.should == $~[2]
-    $3.should == $~[3]
-    $4.should == $~[4]
-
-    [$1, $2, $3, $4].should == ['f', 'o', 'o', nil]
-  end
-end
-
-describe "predefined global $:" do
-  it "is initialized to an array of strings" do
-    $:.is_a?(Array).should == true
-  end
-end
-
-describe "predefined standard objects" do
-  it "includes ARGF" do
-    Object.const_defined?(:ARGF).should == true
-  end
-
-  it "includes ARGV" do
-    Object.const_defined?(:ARGV).should == true
-    ARGV.respond_to?(:[]).should == true
-  end
-
-  # already checked in spec_helper
-  #it "includes a hash-like object ENV" do
-  #  Object.const_defined?(:ENV).should == true
-  #  ENV.respond_to?(:[]).should == true
-  #end
-end
-
-describe "The predefined global constants" do
-  it "includes TRUE" do
-    Object.const_defined?(:TRUE).should == true
-    TRUE.should be_true
-  end
-
-  it "includes FALSE" do
-    Object.const_defined?(:FALSE).should == true
-    FALSE.should be_false
-  end
-
-  it "includes NIL" do
-    Object.const_defined?(:NIL).should == true
-    NIL.should be_nil
-  end
-
-  it "includes STDIN" do
-    Object.const_defined?(:STDIN).should == true
-  end
-
-  it "includes STDOUT" do
-    Object.const_defined?(:STDOUT).should == true
-  end
-
-  it "includes STDERR" do
-    Object.const_defined?(:STDERR).should == true
-  end
-
-  it "includes RUBY_VERSION" do
-    Object.const_defined?(:RUBY_VERSION).should == true
-    RUBY_VERSION.should =~ /^\d\.\d\.\d$/
-  end
-
-  it "includes RUBY_RELEASE_DATE" do
-    Object.const_defined?(:RUBY_RELEASE_DATE).should == true
-  end
-
-  it "includes RUBY_PLATFORM" do
-    Object.const_defined?(:RUBY_PLATFORM).should == true
-    RUBY_PLATFORM.should == "opal"
-  end
-
-  it "includes RUBY_ENGINE" do
-    Object.const_defined?(:RUBY_ENGINE).should == true
-    RUBY_ENGINE.should == "opal"
-  end
-
-  it "includes RUBY_ENGINE_VERSION" do
-    Object.const_defined?(:RUBY_ENGINE_VERSION).should == true
-    RUBY_ENGINE_VERSION.should == Opal::VERSION
-  end
-end