opal 0.11.0.rc1 → 0.11.0

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

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

@@ -1,20 +0,0 @@
-describe "Literal Regexps" do
-  it "yields a Regexp" do
-    /Hello/.should be_kind_of(Regexp)
-  end
-end
-
-describe "Regexps with interpolation" do
-  it "allows interpolation of strings" do
-    str = "foo|bar"
-    /#{str}/.should == /foo|bar/
-  end
-
-  it "allows interpolation to interact with other Regexp constructs" do
-    str = "foo)|(bar"
-    /(#{str})/.should == /(foo)|(bar)/
-
-    str = "a"
-    /[#{str}-z]/.should == /[a-z]/
-  end
-end

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

@@ -1,18 +0,0 @@
-describe 'rescue' do
-  it 'wraps a try{}catch{} to a function when there is a method call on returning value' do
-    begin
-      1 + 1
-    rescue
-    end.should == 2
-  end
-
-  it 'explicitely adds return to the rescue part when there is ensure statement' do
-    begin
-      1 + 1
-    rescue
-      3
-    ensure
-      4
-    end.should == 2
-  end
-end

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

@@ -1,7 +0,0 @@
-describe 'Safe navigator' do
-  it "handles also null and undefined" do
-    [`null`, `undefined`].each do |value|
-      value&.unknown.should == nil
-    end
-  end
-end

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

@@ -1,222 +0,0 @@
-require File.expand_path('../fixtures/send', __FILE__)
-
-# Why so many fixed arg tests?  JRuby and I assume other Ruby impls have
-# separate call paths for simple fixed arity methods.  Testing up to five
-# will verify special and generic arity code paths for all impls.
-#
-# Method naming conventions:
-# M - Manditory Args
-# O - Optional Arg
-# R - Rest Arg
-# Q - Post Manditory Args (1.9)
-
-specs = LangSendSpecs
-
-describe "Invoking a method" do
-  describe "with zero arguments" do
-    it "requires no arguments passed" do
-      specs.fooM0.should == 100
-    end
-
-    it "raises ArgumentError if the method has a positive arity" do
-      lambda {
-        specs.fooM1
-      }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "with only manditory arguments" do
-    it "requires exactly the same number of passed values" do
-      specs.fooM1(1).should == [1]
-      specs.fooM2(1,2).should == [1,2]
-      specs.fooM3(1,2,3).should == [1,2,3]
-      specs.fooM4(1,2,3,4).should == [1,2,3,4]
-      specs.fooM5(1,2,3,4,5).should == [1,2,3,4,5]
-    end
-
-    it "raises ArgumentError if the methods arity doesn't match" do
-      lambda {
-        specs.fooM1(1,2)
-      }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "with optional arguments" do
-    it "uses the optional argument if none is is passed" do
-      specs.fooM0O1.should == [1]
-    end
-
-    it "uses the passed argument if available" do
-      specs.fooM0O1(2).should == [2]
-    end
-
-    it "raises ArgumentError if extra arguments are passed" do
-      lambda {
-        specs.fooM0O1(2,3)
-      }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "with manditory and optional arguments" do
-    it "uses the passed values in left to right order" do
-      specs.fooM1O1(2).should == [2,1]
-    end
-
-    it "raises an ArgumentError if there are no values for the manditory args" do
-      lambda {
-        specs.fooM1O1
-      }.should raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError if too many values are passed" do
-      lambda {
-        specs.fooM1O1(1,2,3)
-      }.should raise_error(ArgumentError)
-    end
-
-    it "keeps the block if supplied" do
-      block = lambda {}
-      specs.fooM1O2(1, foo: :bar, &block).should == [1, {foo: :bar}, block]
-    end
-  end
-
-  describe "with a rest argument" do
-    it "is an empty array if there are no additional arguments" do
-      specs.fooM0R().should == []
-      specs.fooM1R(1).should == [1, []]
-    end
-
-    it "gathers unused arguments" do
-      specs.fooM0R(1).should == [1]
-      specs.fooM1R(1,2).should == [1, [2]]
-    end
-  end
-
-  it "with a block makes it available to yield" do
-    specs.oneb(10) { 200 }.should == [10,200]
-  end
-
-  it "with a block converts the block to a Proc" do
-    prc = specs.makeproc { "hello" }
-    prc.should be_kind_of(Proc)
-    prc.call.should == "hello"
-  end
-
-  it "raises a SyntaxError with both a literal block and an object as block" do
-    lambda {
-      eval "specs.oneb(10, &l){ 42 }"
-    }.should raise_error(SyntaxError)
-  end
-
-  it "with same names as existing variables is ok" do
-    foobar = 100
-
-    def foobar; 200; end
-
-    foobar.should == 100
-    foobar().should == 200
-  end
-
-  it "with splat operator makes the object the direct arguments" do
-    a = [1,2,3]
-    specs.fooM3(*a).should == [1,2,3]
-  end
-
-  it "without parentheses works" do
-    (specs.fooM3 1,2,3).should == [1,2,3]
-  end
-
-  it "with a space separating method name and parenthesis treats expression in parenthesis as first argument" do
-    specs.weird_parens().should == "55"
-  end
-
-  ruby_version_is "" ... "1.9" do
-    describe "allows []=" do
-      before :each do
-        @obj = LangSendSpecs::AttrSet.new
-      end
-
-      it "with *args in the [] expanded to individual arguments" do
-        ary = [2,3]
-        (@obj[1, *ary] = 4).should == 4
-        @obj.result.should == [1,2,3,4]
-      end
-
-      it "with multiple *args" do
-        ary = [2,3]
-        post = [4,5]
-        (@obj[1, *ary] = *post).should == [4,5]
-        @obj.result.should == [1,2,3,[4,5]]
-      end
-
-      it "with multiple *args and unwraps the last splat" do
-        ary = [2,3]
-        post = [4]
-        (@obj[1, *ary] = *post).should == 4
-        @obj.result.should == [1,2,3,4]
-      end
-
-      it "with a *args and multiple rhs args" do
-        ary = [2,3]
-        (@obj[1, *ary] = 4, 5).should == [4,5]
-        @obj.result.should == [1,2,3,[4,5]]
-      end
-    end
-  end
-
-  it "passes literal hashes without curly braces as the last parameter" do
-    specs.fooM3('abc', 456, 'rbx' => 'cool',
-         'specs' => 'fail sometimes', 'oh' => 'weh').should == \
-     ['abc', 456, {'rbx' => 'cool', 'specs' => 'fail sometimes', 'oh' => 'weh'}]
-  end
-
-  it "passes a literal hash without curly braces or parens" do
-    (specs.fooM3 'abc', 456, 'rbx' => 'cool',
-        'specs' => 'fail sometimes', 'oh' => 'weh').should == \
-     ['abc', 456, { 'rbx' => 'cool', 'specs' => 'fail sometimes', 'oh' => 'weh'}]
-  end
-
-  it "allows to literal hashes without curly braces as the only parameter" do
-    specs.fooM1(:rbx => :cool, :specs => :fail_sometimes).should ==
-      [{ :rbx => :cool, :specs => :fail_sometimes }]
-
-    (specs.fooM1 :rbx => :cool, :specs => :fail_sometimes).should ==
-      [{ :rbx => :cool, :specs => :fail_sometimes }]
-  end
-
-  describe "when the method is not available" do
-    it "invokes method_missing" do
-      o = LangSendSpecs::MethodMissing.new
-      o.not_there(1,2)
-      o.message.should == :not_there
-      o.args.should == [1,2]
-    end
-  end
-
-end
-
-describe "Invoking a private setter method" do
-  describe "permits self as a receiver" do
-    it "for normal assignment" do
-      receiver = LangSendSpecs::PrivateSetter.new
-      receiver.call_self_foo_equals(42)
-      receiver.foo.should == 42
-    end
-
-    it "for multiple assignment" do
-      receiver = LangSendSpecs::PrivateSetter.new
-      receiver.call_self_foo_equals_masgn(42)
-      receiver.foo.should == 42
-    end
-  end
-end
-
-describe "Invoking a private getter method" do
-  it "does not permit self as a receiver" do
-    receiver = LangSendSpecs::PrivateGetter.new
-    lambda { receiver.call_self_foo }.should raise_error(NoMethodError)
-    lambda { receiver.call_self_foo_or_equals(6) }.should raise_error(NoMethodError)
-  end
-end
-
-# language_version __FILE__, "send"