opal 0.10.0 → 0.11.0

data/spec/opal/core/module/fixtures/classes.rb

@@ -1,444 +0,0 @@
-module ModuleSpecs
-  CONST = :plain_constant
-
-  class Subclass < Module
-  end
-
-  class SubclassSpec
-  end
-
-  class RemoveClassVariable
-  end
-
-  module LookupModInMod
-    INCS = :ethereal
-  end
-
-  module LookupMod
-    include LookupModInMod
-
-    MODS = :rockers
-  end
-
-  class Lookup
-    include LookupMod
-    LOOKIE = :lookie
-  end
-
-  class LookupChild < Lookup
-  end
-
-  class Parent
-    # For private_class_method spec
-    #def self.private_method; end
-    #private_class_method :private_method
-
-    def undefed_method() end
-    undef_method :undefed_method
-
-    def parent_method; end
-    def another_parent_method; end
-
-    # For public_class_method spec
-    private
-    def self.public_method; end
-    # public_class_method :public_method
-
-    public
-    def public_parent() end
-
-    protected
-    def protected_parent() end
-
-    private
-    def private_parent() end
-  end
-
-  module Basic
-    def public_module() end
-
-    protected
-    def protected_module() end
-
-    private
-    def private_module() end
-  end
-
-  module Super
-    include Basic
-
-    def public_super_module() end
-
-    protected
-    def protected_super_module() end
-
-    private
-    def private_super_module() end
-
-    def super_included_method; end
-
-    class SuperChild
-    end
-  end
-
-  module Internal
-  end
-
-  class Child < Parent
-    include Super
-
-    class << self
-      # include Internal
-    end
-    attr_accessor :accessor_method
-
-    def undefed_child() end
-
-    def public_child() end
-
-    undef_method :parent_method
-    undef_method :another_parent_method
-
-    protected
-    def protected_child() end
-
-    private
-    def private_child() end
-  end
-
-  class Grandchild < Child
-    undef_method :super_included_method
-  end
-
-  class Child2 < Parent
-    attr_reader :foo
-  end
-
-  # Be careful touching the Counts* classes as there used for testing
-  # private_instance_methods, public_instance_methods, etc.  So adding, removing
-  # a method will break those tests.
-  module CountsMixin
-    def public_3; end
-    public :public_3
-
-    def private_3; end
-    private :private_3
-
-    def protected_3; end
-    protected :protected_3
-  end
-
-  class CountsParent
-    include CountsMixin
-
-    def public_2; end
-
-    private
-    def private_2; end
-
-    protected
-    def protected_2; end
-  end
-
-  class CountsChild < CountsParent
-    def public_1; end
-
-    private
-    def private_1; end
-
-    protected
-    def protected_1; end
-  end
-
-  module AddConstant
-  end
-
-  module A
-    CONSTANT_A = :a
-    OVERRIDE = :a
-    def ma(); :a; end
-    def self.cma(); :a; end
-  end
-
-  module B
-    CONSTANT_B = :b
-    OVERRIDE = :b
-    include A
-    def mb(); :b; end
-    def self.cmb(); :b; end
-  end
-
-  class C
-    OVERRIDE = :c
-    include B
-  end
-
-  module Z
-    MODULE_SPEC_TOPLEVEL_CONSTANT = 1
-  end
-
-  module Alias
-    def report() :report end
-    alias publish report
-  end
-
-  class Allonym
-    include ModuleSpecs::Alias
-  end
-
-  class Aliasing
-    def self.make_alias(*a)
-      alias_method(*a)
-    end
-
-    def public_one; 1; end
-
-    def public_two(n); n * 2; end
-
-    private
-    def private_one; 1; end
-
-    protected
-    def protected_one; 1; end
-  end
-
-  module AliasingSuper
-
-    module Parent
-      def super_call(arg)
-        arg
-      end
-    end
-
-    module Child
-      include Parent
-      def super_call(arg)
-        super(arg)
-      end
-    end
-
-    class Target
-      include Child
-      alias_method :alias_super_call, :super_call
-      alias_method :super_call, :alias_super_call
-    end
-  end
-
-
-  module ReopeningModule
-    def foo; true; end
-    # module_function :foo
-    private :foo
-  end
-
-  # Yes, we want to re-open the module
-  module ReopeningModule
-    alias :foo2 :foo
-    # module_function :foo2
-  end
-
-  module Nesting
-    @tests = {}
-    def self.[](name); @tests[name]; end
-    def self.[]=(name, val); @tests[name] = val; end
-    def self.meta; class << self; self; end; end
-
-    # Nesting[:basic] = Module.nesting
-
-    module ::ModuleSpecs
-      # Nesting[:open_first_level] = Module.nesting
-    end
-
-    class << self
-      # Nesting[:open_meta] = Module.nesting
-    end
-
-    def self.called_from_module_method
-      # Module.nesting
-    end
-
-    class NestedClass
-      # Nesting[:nest_class] = Module.nesting
-
-      def self.called_from_class_method
-        # Module.nesting
-      end
-
-      def called_from_inst_method
-        # Module.nesting
-      end
-    end
-
-  end
-
-  # Nesting[:first_level] = Module.nesting
-
-  module InstanceMethMod
-    def bar(); :bar; end
-  end
-
-  class InstanceMeth
-    include InstanceMethMod
-    def foo(); :foo; end
-  end
-
-  class InstanceMethChild < InstanceMeth
-  end
-
-  module ClassVars
-    class A
-      @@a_cvar = :a_cvar
-    end
-
-    module M
-      @@m_cvar = :m_cvar
-    end
-
-    class B < A
-      include M
-
-      @@b_cvar = :b_cvar
-    end
-  end
-
-  class CVars
-    @@cls = :class
-
-    class << self
-      def cls
-        @@cls
-      end
-      @@meta = :meta
-    end
-
-    def self.meta
-      @@meta
-    end
-
-    def meta
-      @@meta
-    end
-  end
-
-  module MVars
-    @@mvar = :mvar
-  end
-
-  class SubModule < Module
-    attr_reader :special
-    def initialize
-      @special = 10
-    end
-  end
-
-  module MA; end
-  module MB
-    include MA
-  end
-  module MC; end
-
-  class MultipleIncludes
-    include MB
-  end
-
-  # empty modules
-  module M1; end
-  module M2; end
-
-  module Autoload
-    def self.use_ex1
-      begin
-        begin
-          raise "test exception"
-        rescue ModuleSpecs::Autoload::EX1
-        end
-      rescue RuntimeError
-        return :good
-      end
-    end
-  end
-
-  # This class isn't inherited from or included in anywhere. It exists to test
-  # 1.9's constant scoping rules
-  class Detached
-    DETATCHED_CONSTANT = :d
-  end
-
-  class ParentPrivateMethodRedef
-    private
-    def private_method_redefined
-      :before_redefinition
-    end
-  end
-
-  class ChildPrivateMethodMadePublic < ParentPrivateMethodRedef
-    public :private_method_redefined
-  end
-
-  class ParentPrivateMethodRedef
-    def private_method_redefined
-      :after_redefinition
-    end
-  end
-
-  module CyclicAppendA
-  end
-
-  module CyclicAppendB
-    include CyclicAppendA
-  end
-
-  module ExtendObject
-    C = :test
-    def test_method
-      "hello test"
-    end
-  end
-
-  module ExtendObjectPrivate
-    class << self
-      def extend_object(obj)
-        ScratchPad.record :extended
-      end
-      private :extend_object
-    end
-  end
-end
-
-class Object
-  def module_specs_public_method_on_object; end
-
-  def module_specs_private_method_on_object; end
-  private :module_specs_private_method_on_object
-
-  def module_specs_protected_method_on_object; end
-  protected :module_specs_private_method_on_object
-
-  def module_specs_private_method_on_object_for_kernel_public; end
-  private :module_specs_private_method_on_object_for_kernel_public
-
-  def module_specs_public_method_on_object_for_kernel_protected; end
-  def module_specs_public_method_on_object_for_kernel_private; end
-end
-
-module Kernel
-  def module_specs_public_method_on_kernel; end
-
-  alias_method :module_specs_alias_on_kernel, :module_specs_public_method_on_object
-
-  public :module_specs_private_method_on_object_for_kernel_public
-  protected :module_specs_public_method_on_object_for_kernel_protected
-  private :module_specs_public_method_on_object_for_kernel_private
-end
-
-class Class
-  def test_method_overlapping_module_method
-    :class
-  end
-end
-
-class Module
-  def test_method_overlapping_module_method
-    :module
-  end
-end

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

@@ -1,48 +0,0 @@
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Module#method_defined?" do
-  it "returns true if a public or private method with the given name is defined in self, self's ancestors or one of self's included modules" do
-    # Defined in Child
-    ModuleSpecs::Child.method_defined?(:public_child).should == true
-    ModuleSpecs::Child.method_defined?("private_child").should == false
-    ModuleSpecs::Child.method_defined?(:accessor_method).should == true
-
-    # Defined in Parent
-    # ModuleSpecs::Child.method_defined?("public_parent").should == true
-    # ModuleSpecs::Child.method_defined?(:private_parent).should == false
-
-    # Defined in Module
-    # ModuleSpecs::Child.method_defined?(:public_module).should == true
-    # ModuleSpecs::Child.method_defined?(:protected_module).should == true
-    # ModuleSpecs::Child.method_defined?(:private_module).should == false
-
-    # Defined in SuperModule
-    # ModuleSpecs::Child.method_defined?(:public_super_module).should == true
-    # ModuleSpecs::Child.method_defined?(:protected_super_module).should == true
-    # ModuleSpecs::Child.method_defined?(:private_super_module).should == false
-  end
-
-  # unlike alias_method, module_function, public, and friends,
-  it "does not search Object or Kernel when called on a module" do
-    m = Module.new
-
-    m.method_defined?(:module_specs_public_method_on_kernel).should be_false
-  end
-
-  it "raises a TypeError when the given object is not a string/symbol/fixnum" do
-    c = Class.new
-    o = mock('123')
-
-    lambda { c.method_defined?(o) }.should raise_error(TypeError)
-
-    o.should_receive(:to_str).and_return(123)
-    lambda { c.method_defined?(o) }.should raise_error(TypeError)
-  end
-
-  it "converts the given name to a string using to_str" do
-    c = Class.new { def test(); end }
-    (o = mock('test')).should_receive(:to_str).and_return("test")
-
-    c.method_defined?(o).should == true
-  end
-end

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

@@ -1,13 +0,0 @@
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe 'Method lookup for instances of Module' do
-  it 'takes own method, not the one defined on the Class' do
-    Module.new.test_method_overlapping_module_method.should == :module
-  end
-end
-
-describe 'Method lookup for instances of Class' do
-  it 'takes own method, not the one defined on the Module' do
-    Class.new.test_method_overlapping_module_method.should == :class
-  end
-end

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

@@ -1,25 +0,0 @@
-describe "Module#module_function with specific method names" do
-  it "creates duplicates of the given instance methods on the Module object" do
-    m = Module.new do
-      def test()  end
-      def test2() end
-      def test3() end
-
-      module_function :test, :test2
-    end
-
-    m.respond_to?(:test).should  == true
-    m.respond_to?(:test2).should == true
-    m.respond_to?(:test3).should == false
-  end
-
-  it "returns the current module" do
-    x = nil
-    m = Module.new do
-      def test()  end
-      x = module_function :test
-    end
-
-    x.should == m
-  end
-end

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

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-module ModuleNameSpec
-  module A
-    class B
-    end
-  end
-
-  Subclass = Class.new(Hash)
-end
-
-describe "Module#name" do
-  it "should return the class name for boot types" do
-    BasicObject.name.should == "BasicObject"
-    Object.name.should == "Object"
-    Class.name.should == "Class"
-    Module.name.should == "Module"
-  end
-
-  it "should return class name for bridged classes" do
-    Array.name.should == "Array"
-  end
-
-  it "should return name for modules and classes" do
-    Enumerator.name.should == "Enumerator"
-    Enumerable.name.should == "Enumerable"
-  end
-
-  it "should return nil for anonymous class" do
-    Class.new.name.should == nil
-  end
-
-  it "should join nested classes using '::'" do
-    ModuleNameSpec::A.name.should == "ModuleNameSpec::A"
-    ModuleNameSpec::A::B.name.should == "ModuleNameSpec::A::B"
-  end
-
-  it 'returns correct constant name when created using Const = Class.new(Superclass)' do
-    ModuleNameSpec::Subclass.name.should == "ModuleNameSpec::Subclass"
-  end
-end

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

@@ -1,18 +0,0 @@
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "Module#public_method_defined?" do
-  it "returns true if the named public method is defined by module or its ancestors" do
-    ModuleSpecs::CountsMixin.public_method_defined?("public_3").should == true
-
-    ModuleSpecs::CountsParent.public_method_defined?("public_3").should == true
-    ModuleSpecs::CountsParent.public_method_defined?("public_2").should == true
-
-    ModuleSpecs::CountsChild.public_method_defined?("public_3").should == true
-    ModuleSpecs::CountsChild.public_method_defined?("public_2").should == true
-    ModuleSpecs::CountsChild.public_method_defined?("public_1").should == true
-  end
-
-  it "returns false if the named method is not defined by the module or its ancestors" do
-    ModuleSpecs::CountsMixin.public_method_defined?(:public_10).should == false
-  end
-end

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

@@ -1,22 +0,0 @@
-require File.expand_path('../../fixtures/constants', __FILE__)
-
-describe "Module#remove_const" do
-  it "removes the constant specified by a String or Symbol from the receiver's constant table" do
-    ConstantSpecs::ModuleM::CS_CONST252 = :const252
-    ConstantSpecs::ModuleM::CS_CONST252.should == :const252
-
-    ConstantSpecs::ModuleM.send :remove_const, :CS_CONST252
-    lambda { ConstantSpecs::ModuleM::CS_CONST252 }.should raise_error(NameError)
-
-    ConstantSpecs::ModuleM::CS_CONST253 = :const253
-    ConstantSpecs::ModuleM::CS_CONST253.should == :const253
-
-    ConstantSpecs::ModuleM.send :remove_const, "CS_CONST253"
-    lambda { ConstantSpecs::ModuleM::CS_CONST253 }.should raise_error(NameError)
-  end
-
-  it "returns the value of the removed constant" do
-    ConstantSpecs::ModuleM::CS_CONST254 = :const254
-    ConstantSpecs::ModuleM.send(:remove_const, :CS_CONST254).should == :const254
-  end
-end

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

@@ -1,66 +0,0 @@
-require File.expand_path('../fixtures/classes', __FILE__)
-
-module ModuleSpecs
-  class NoInheritance
-    def method_to_undef() 1 end
-    def another_method_to_undef() 1 end
-  end
-
-  class Parent
-    def method_to_undef() 1 end
-    def another_method_to_undef() 1 end
-  end
-
-  class Child < Parent
-  end
-
-  class Ancestor
-    def method_to_undef() 1 end
-    def another_method_to_undef() 1 end
-  end
-
-  class Descendant < Ancestor
-  end
-end
-
-describe "Module#undef_method with symbol" do
-  it "removes a method defined in a class" do
-    x = ModuleSpecs::NoInheritance.new
-
-    x.method_to_undef.should == 1
-
-    ModuleSpecs::NoInheritance.send :undef_method, :method_to_undef
-
-    lambda { x.method_to_undef }.should raise_error(NoMethodError)
-  end
-
-  it "removes a method defined in a super class" do
-    child = ModuleSpecs::Child.new
-    child.method_to_undef.should == 1
-
-    ModuleSpecs::Child.send :undef_method, :method_to_undef
-
-    lambda { child.method_to_undef }.should raise_error(NoMethodError)
-  end
-end
-
-describe "Module#undef_method with string" do
-  it "removes a method defined in a class" do
-    x = ModuleSpecs::NoInheritance.new
-
-    x.another_method_to_undef.should == 1
-
-    ModuleSpecs::NoInheritance.send :undef_method, 'another_method_to_undef'
-
-    lambda { x.another_method_to_undef }.should raise_error(NoMethodError)
-  end
-
-  it "removes a method defined in a super class" do
-    child = ModuleSpecs::Child.new
-    child.another_method_to_undef.should == 1
-
-    ModuleSpecs::Child.send :undef_method, 'another_method_to_undef'
-
-    lambda { child.another_method_to_undef }.should raise_error(NoMethodError)
-  end
-end

data/spec/opal/core/numeric/bit_and_spec.rb

@@ -1,7 +0,0 @@
-describe "Numeric#&" do
-  it "returns self bitwise AND other" do
-    (256 & 16).should == 0
-    (2010 & 5).should == 0
-    (65535 & 1).should == 1
-  end
-end

data/spec/opal/core/numeric/bit_or_spec.rb

@@ -1,8 +0,0 @@
-describe "Numeric#|" do
-  it "returns self bitwise OR other" do
-    (1 | 0).should == 1
-    (5 | 4).should == 5
-    (5 | 6).should == 7
-    (248 | 4096).should == 4344
-  end
-end

data/spec/opal/core/numeric/bit_xor_spec.rb

@@ -1,6 +0,0 @@
-describe "Numeric#^" do
-  it "returns self bitwise EXCLUSIVE OR other" do
-    (3 ^ 5).should == 6
-    (-2 ^ -255).should == 255
-  end
-end

data/spec/opal/core/numeric/ceil_spec.rb

@@ -1,8 +0,0 @@
-describe "Numeric#ceil" do
-  it "returns the ceil'ed value" do
-    1.ceil.should == 1
-    (-42).ceil.should == -42
-    3.142.ceil.should == 4
-    0.ceil.should == 0
-  end
-end