opal 0.11.0.rc1 → 0.11.0

data/spec/opal/core/language/versions/symbol_1.9.rb

@@ -1,15 +0,0 @@
-describe "A Symbol literal" do
-  it "can be an empty string" do
-    c = :''
-    c.should be_kind_of(Symbol)
-    c.inspect.should == ':""'
-  end
-
-  # These weren't allowed on 1.8
-  it "can be :!, :!=, or :!~" do
-    %w{'!', '!=', '!~'}.each do |sym|
-      lambda { sym.to_sym }.should_not raise_error(SyntaxError)
-      sym.to_sym.to_s.should == sym
-    end
-  end
-end

data/spec/opal/core/language/versions/variables_1.9.rb

@@ -1,8 +0,0 @@
-describe "Multiple assignments with splats" do
-  it "* on the LHS has to be applied to any parameter" do
-    a, *b, c = 1, 2, 3
-    a.should == 1
-    b.should == [2]
-    c.should == 3
-  end
-end

data/spec/opal/core/language_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-describe "begin & rescue blocks" do
-  it "should evaluate to begin blocks last expression when no exception" do
-    result = begin
-      "a"
-    rescue
-      "b"
-    end
-
-    result.should == "a"
-  end
-
-  it "should evaluate to rescue blocks last expression when exception" do
-    result = begin
-      raise "foo"
-    rescue
-      "bar"
-    end
-
-    result.should == "bar"
-  end
-end
-
-describe "generated method names" do
-  it "does not conflict with local Ruby variables" do
-    Class.new {
-      value = 123
-      def value
-        456
-      end
-      value.should == 123
-    }
-  end
-
-  it "does not conflict with local JS variables" do
-    Class.new {
-      `var value = 123;`
-      def value
-        456
-      end
-      `value`.should == 123
-    }
-  end
-end
-
-describe 'undef with dynamic symbol (regression for https://github.com/opal/opal/pull/1128)' do
-  class UndefWithDynamicSymbol
-    def foo_bar
-    end
-  end
-
-  class UndefWithDynamicSymbol
-    bar = "bar"
-    undef :"foo_#{bar}"
-  end
-
-  it 'should work' do
-    lambda { UndefWithDynamicSymbol.new.foo_bar }.should raise_error(NoMethodError)
-  end
-end
-
-describe 'alias with dynamic symbol (regression for https://github.com/opal/opal/pull/1128)' do
-  class AliasWithDynamicSymbol
-    def method1
-    end
-  end
-
-  class AliasWithDynamicSymbol
-    alias :"method#{2}" :"method#{1}"
-  end
-
-  it 'should work' do
-    AliasWithDynamicSymbol.new.should respond_to(:method1)
-    AliasWithDynamicSymbol.new.should respond_to(:method2)
-  end
-end

data/spec/opal/core/marshal/dump_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-module MarshalExtension
-end
-
-class MarshalUserRegexp < Regexp
-end
-
-class UserMarshal
-  attr_reader :data
-
-  def initialize
-    @data = 'stuff'
-  end
-  def marshal_dump() 'data' end
-  def marshal_load(data) @data = data end
-  def ==(other) self.class === other and @data == other.data end
-end
-
-describe 'Marshal.dump' do
-  it 'dumps non-empty Array' do
-    expect(Marshal.dump(['a', 1, 2])).to eq("\u0004\b[\b\"\u0006ai\u0006i\a")
-  end
-
-  it 'dumps case-sensitive regexp' do
-    expect(Marshal.dump(/\w+/)).to eq("\u0004\b/\b\\w+\u0000")
-  end
-
-  it 'dumps case-insensitive regexp' do
-    expect(Marshal.dump(/\w+/i)).to eq("\u0004\b/\b\\w+\u0001")
-  end
-
-  it "dumps a Float" do
-    Marshal.dump(123.4567).should == "\004\bf\r123.4567"
-    Marshal.dump(-0.841).should == "\x04\bf\v-0.841"
-    Marshal.dump(9876.345).should == "\004\bf\r9876.345"
-    Marshal.dump(Float::INFINITY).should == "\004\bf\binf"
-    Marshal.dump(-Float::INFINITY).should == "\004\bf\t-inf"
-    Marshal.dump(Float::NAN).should == "\004\bf\bnan"
-  end
-
-  it "dumps a Regexp with flags" do
-    Marshal.dump(/\w/im).should == "\x04\b/\a\\w\u0005"
-  end
-
-  it 'dumps an extended Regexp' do
-    Marshal.dump(/\w/.extend(MarshalExtension)).should == "\x04\be:\u0015MarshalExtension/\a\\w\u0000"
-  end
-
-  it 'dumps object#marshal_dump when object responds to #marshal_dump' do
-    Marshal.dump(UserMarshal.new).should == "\u0004\bU:\u0010UserMarshal\"\tdata"
-  end
-end

data/spec/opal/core/marshal/load_spec.rb

@@ -1,7 +0,0 @@
-describe "Marshal.load" do
-  it 'loads array with instance variable' do
-    a = Marshal.load("\x04\bI[\bi\x06i\ai\b\x06:\n@ivari\x01{")
-    a.should == [1, 2, 3]
-    a.instance_variable_get(:@ivar).should == 123
-  end
-end

data/spec/opal/core/method/to_proc_spec.rb

@@ -1,28 +0,0 @@
-describe "Method#to_proc" do
-
-  it "returns a Proc object that is bound to the method's receiver" do
-    "hello".method(:capitalize).to_proc.call.should == "Hello"
-    "hello".method(:upcase).to_proc.call.should == "HELLO"
-  end
-
-  it "works with class methods" do
-    class Lender
-      def self.abc
-        self
-      end
-      def self.xyz
-        abc
-      end
-    end
-
-    module Namespace
-      class Borrower
-        class << self
-          define_method(:xyz, &::Lender.method(:xyz))
-        end
-      end
-    end
-
-    Namespace::Borrower.xyz.should == Lender
-  end
-end

data/spec/opal/core/module/alias_method_spec.rb

@@ -1,28 +0,0 @@
-class AliasMethodSpec
-  module M
-    def something
-      3.142
-    end
-
-    alias_method :something_else, :something
-  end
-
-  include M
-
-  def foo; 'foo'; end
-  alias_method :bar, :foo
-end
-
-describe "Module#alias_method" do
-  it "makes a copy of the method" do
-    AliasMethodSpec.new.bar.should == 'foo'
-  end
-
-  describe "inside a module" do
-    it "defined methods that get donated to a class when included" do
-      obj = AliasMethodSpec.new
-      obj.something.should == 3.142
-      obj.something_else.should == 3.142
-    end
-  end
-end

data/spec/opal/core/module/ancestors_spec.rb

@@ -1,11 +0,0 @@
-module ModuleAncestorsSpec
-  class A; end
-  class B < A; end
-end
-
-describe "Module#ancestors" do
-  it "returns a list of modules in self (including self)" do
-    ModuleAncestorsSpec::B.ancestors.include?(ModuleAncestorsSpec::B).should == true
-    ModuleAncestorsSpec::B.ancestors.include?(ModuleAncestorsSpec::A).should == true
-  end
-end

data/spec/opal/core/module/append_features_spec.rb

@@ -1,14 +0,0 @@
-module AppendFeaturesSpec
-  class Klass; end
-
-  def self.append_features(mod)
-    ScratchPad.record mod
-  end
-end
-
-describe "Module#append_features" do
-  it "gets called when self is included in another module/class" do
-    AppendFeaturesSpec::Klass.include AppendFeaturesSpec
-    ScratchPad.recorded.should == AppendFeaturesSpec::Klass
-  end
-end

data/spec/opal/core/module/attr_accessor_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-module AttrAccessorSpec
-  module M
-    attr_accessor :foo
-  end
-
-  class C
-    include M
-  end
-end
-
-describe "Module#attr_accessor" do
-  it "can be passed a splat of arguments" do
-    eval "class OpalAttrAccessorSpec; attr_accessor *%w{foo bar baz}; end"
-    OpalAttrAccessorSpec.new.foo.should be_nil
-  end
-
-  describe "inside a module" do
-    it "defines methods that get donated to a class when included" do
-      obj = AttrAccessorSpec::C.new
-      obj.foo = 100
-      obj.foo.should == 100
-    end
-  end
-end

data/spec/opal/core/module/const_defined_spec.rb

@@ -1,84 +0,0 @@
-require File.expand_path('../../fixtures/constants', __FILE__)
-
-CD_CONST1 = :const1
-
-module ConstDefinedSpecs
-  FOO = 100
-
-  module Bar
-    BAR = 200
-
-    module Baz
-      BAZ = 300
-    end
-  end
-
-  class Dog
-    LEGS = 4
-  end
-
-  class Bloudhound < Dog
-  end
-end
-
-describe "Module#const_defined?" do
-  it "should consider constants with values that evaluate to false in a JavaScript conditional as defined" do
-    Object.const_defined?("CS_NIL").should be_true
-    Object.const_defined?("CS_ZERO").should be_true
-    Object.const_defined?("CS_BLANK").should be_true
-    Object.const_defined?("CS_FALSE").should be_true
-  end
-
-  it "accepts a String or Symbol name" do
-    Object.const_defined?(:CD_CONST1).should be_true
-    Object.const_defined?("CD_CONST1").should be_true
-  end
-
-  it "should return false if no constant is defined in the search path" do
-    Object.const_defined?(:CS_CONSTX_BAD).should be_false
-  end
-
-  it "raises a NameError if the name does not start with a capital letter" do
-    lambda { ConstantSpecs.const_defined? "name" }.should raise_error(NameError)
-  end
-
-  it "raises a NameError if the name starts with a non-alphabetic character" do
-    lambda { ConstantSpecs.const_defined? "__CONSTX__" }.should raise_error(NameError)
-    lambda { ConstantSpecs.const_defined? "@Name" }.should raise_error(NameError)
-    lambda { ConstantSpecs.const_defined? "!Name" }.should raise_error(NameError)
-  end
-
-  it "raises a NameError if the name contains non-word characters" do
-    # underscore (i.e., _) is a valid word character
-    ConstantSpecs.const_defined?("CD_CONST1").should be_true
-    lambda { ConstantSpecs.const_defined? "Name=" }.should raise_error(NameError)
-    lambda { ConstantSpecs.const_defined? "Name?" }.should raise_error(NameError)
-  end
-
-  it "searches parent scopes of classes and modules" do
-    Module.const_defined?(:ConstDefinedSpecs).should be_true
-    ConstDefinedSpecs.const_defined?(:ConstDefinedSpecs).should be_true
-    ConstDefinedSpecs::Bar::Baz.const_defined?(:BAZ).should be_true
-    ConstDefinedSpecs::Bar::Baz.const_defined?(:CD_CONST1).should be_true
-    ConstDefinedSpecs::Bar::Baz.const_defined?(:BAR).should be_false
-    ConstDefinedSpecs::Bar::Baz.const_defined?(:FOO).should be_false
-    ConstDefinedSpecs::Bar::Baz.const_defined?(:Bar).should be_false
-    ConstDefinedSpecs::Bar::Baz.const_defined?(:ConstDefinedSpecs).should be_true
-    ConstDefinedSpecs::Dog.const_defined?(:LEGS).should be_true
-    ConstDefinedSpecs::Dog.const_defined?(:Dog).should be_false
-    ConstDefinedSpecs::Bloudhound.const_defined?(:LEGS).should be_true
-  end
-
-  it "should not search parent scopes of classes and modules if inherit is false" do
-    Module.const_defined?(:ConstDefinedSpecs, false).should be_false
-    ConstDefinedSpecs.const_defined?(:ConstDefinedSpecs, false).should be_false
-    ConstDefinedSpecs::Dog.const_defined?(:LEGS, false).should be_true
-    ConstDefinedSpecs::Dog.const_defined?(:Dog, false).should be_false
-    ConstDefinedSpecs::Bloudhound.const_defined?(:LEGS, false).should be_false
-  end
-
-  it "should search parent scopes of classes and modules for Object regardless of inherit value" do
-    Object.const_defined?(:ConstDefinedSpecs).should be_true
-    Object.const_defined?(:ConstDefinedSpecs, false).should be_true
-  end
-end

data/spec/opal/core/module/const_get_spec.rb

@@ -1,85 +0,0 @@
-require File.expand_path('../../fixtures/constants', __FILE__)
-
-CS_CONST1 = :const1
-
-module ConstGetSpecs
-  FOO = 100
-
-  module Bar
-    BAR = 200
-
-    module Baz
-      BAZ = 300
-    end
-  end
-
-  class Dog
-    LEGS = 4
-  end
-
-  class Bloudhound < Dog
-  end
-end
-
-describe "Module#const_get" do
-  it "should get constants with values that evaluate to false in a JavaScript conditional" do
-    Object.const_get("CS_NIL").should be_nil
-    Object.const_get("CS_ZERO").should == 0
-    Object.const_get("CS_BLANK").should == ""
-    Object.const_get("CS_FALSE").should == false
-  end
-
-  it "accepts a String or Symbol name" do
-    Object.const_get(:CS_CONST1).should == :const1
-    Object.const_get("CS_CONST1").should == :const1
-  end
-
-  it "raises a NameError if no constant is defined in the search path" do
-    lambda { Object.const_get :CS_CONSTX_BAD }.should raise_error(NameError)
-  end
-
-  it "raises a NameError if the name does not start with a capital letter" do
-    lambda { ConstantSpecs.const_get "name" }.should raise_error(NameError)
-  end
-
-  it "raises a NameError if the name starts with a non-alphabetic character" do
-    lambda { ConstantSpecs.const_get "__CONSTX__" }.should raise_error(NameError)
-    lambda { ConstantSpecs.const_get "@Name" }.should raise_error(NameError)
-    lambda { ConstantSpecs.const_get "!Name" }.should raise_error(NameError)
-    lambda { ConstantSpecs.const_get "::Name" }.should raise_error(NameError)
-  end
-
-  it "raises a NameError if the name contains non-word characters" do
-    # underscore (i.e., _) is a valid word character
-    ConstantSpecs.const_get("CS_CONST1").should == :const1
-    lambda { ConstantSpecs.const_get "Name=" }.should raise_error(NameError)
-    lambda { ConstantSpecs.const_get "Name?" }.should raise_error(NameError)
-  end
-
-  it "searches parent scopes of classes and modules" do
-    Module.const_get(:ConstGetSpecs).should == ConstGetSpecs
-    ConstGetSpecs.const_get(:ConstGetSpecs).should == ConstGetSpecs
-    ConstGetSpecs::Bar::Baz.const_get(:BAZ).should == 300
-    ConstGetSpecs::Bar::Baz.const_get(:CS_CONST1).should == :const1
-    lambda { ConstGetSpecs::Bar::Baz.const_get(:BAR) }.should raise_error(NameError)
-    lambda { ConstGetSpecs::Bar::Baz.const_get(:FOO) }.should raise_error(NameError)
-    lambda { ConstGetSpecs::Bar::Baz.const_get(:Bar) }.should raise_error(NameError)
-    ConstGetSpecs::Bar::Baz.const_get(:ConstGetSpecs).should == ConstGetSpecs
-    ConstGetSpecs::Dog.const_get(:LEGS).should == 4
-    lambda { ConstGetSpecs::Dog.const_get(:Dog) }.should raise_error(NameError)
-    ConstGetSpecs::Bloudhound.const_get(:LEGS).should == 4
-  end
-
-  it "should not search parent scopes of classes and modules if inherit is false" do
-    lambda { Module.const_get(:ConstGetSpecs, false) }.should raise_error(NameError)
-    lambda { ConstGetSpecs.const_get(:ConstGetSpecs, false) }.should raise_error(NameError)
-    ConstGetSpecs::Dog.const_get(:LEGS, false).should == 4
-    lambda { ConstGetSpecs::Dog.const_get(:Dog, false) }.should raise_error(NameError)
-    lambda { ConstGetSpecs::Bloudhound.const_get(:LEGS, false) }.should raise_error(NameError)
-  end
-
-  it "should search parent scopes of classes and modules for Object regardless of inherit value" do
-    Object.const_get(:ConstGetSpecs).should == ConstGetSpecs
-    Object.const_get(:ConstGetSpecs, false).should == ConstGetSpecs
-  end
-end