opal 0.3.41 → 0.3.42

data/spec/core/enumerable/grep_spec.rb

@@ -1,3 +1,6 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 class EnumerableSpecGrep
   def ===(obj); obj == '2'; end
 end
@@ -18,4 +21,4 @@ describe "Enumerable#grep" do
   it "grep with a block should return an array of elements === pattern passed through block" do
     EnumerableSpecs::Numerous.new("cat", "coat", "car", "cadr", "cost").grep(EnumerableSpecGrep2.new) { |i| i.upcase }.should == ["CAT", "CAR", "CADR"]
   end
-end
+end

data/spec/core/enumerable/take_spec.rb

@@ -1,3 +1,6 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Enumerable#take" do
   before :each do
     @values = [4,3,2,1,0,-1]
@@ -37,4 +40,4 @@ describe "Enumerable#take" do
     @enum.take(100).should == @values
     @enum.take(8).should == @values
   end
-end
+end

data/spec/core/enumerable/to_a_spec.rb

@@ -1,6 +1,9 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
 describe "Enumerable#to_a" do
   it "returns an array containing the elements" do
     numerous = EnumerableSpecs::Numerous.new(1, nil, 'a', 2, false, true)
     numerous.to_a.should == [1, nil, "a", 2, false, true]
   end
-end
+end

data/spec/core/false/and_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "FalseClass#&" do
+  it "returns false" do
+    (false & false).should == false
+    (false & true).should == false
+    (false & nil).should == false
+    (false & "").should == false
+    (false & mock('x')).should == false
+  end
+end

data/spec/core/false/inspect_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "FalseClass#inspect" do
+  it "returns the string 'false'" do
+    false.inspect.should == "false"
+  end
+end

data/spec/core/false/or_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "FalseClass#|" do
+  it "return false if other is nil or false, otherwise true" do
+    (false | false).should == false
+    (false | true).should == true
+    (false | nil).should == false
+    (false | "").should == true
+    (false | mock('x')).should == true
+  end
+end

data/spec/core/false/to_s_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "FalseClass#to_s" do
+  it "returns the string 'false'" do
+    false.to_s.should == "false"
+  end
+end

data/spec/core/false/xor_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "FalseClass#^" do
+  it "returns false if other is nil or false, otherwise true" do
+    (false ^ false).should == false
+    (false ^ true).should == true
+    (false ^ nil).should == false
+    (false ^ "").should == true
+    (false ^ mock('x')).should == true
+  end
+end

data/spec/core/kernel/rand_spec.rb

@@ -1,14 +1,14 @@
 describe "Kernel.rand" do
-  it "returns a float if no argument is passed" do
-    # rand.should be_kind_of(Float)
+  pending "returns a float if no argument is passed" do
+    rand.should be_kind_of(Float)
   end
 
-  it "returns an integer for an integer argument" do
-    # rand(77).should be_kind_of(Integer)
+  pending "returns an integer for an integer argument" do
+    rand(77).should be_kind_of(Integer)
   end
 
   it "returns a numeric in opal" do
     rand.should be_kind_of(Numeric)
     rand(77).should be_kind_of(Numeric)
   end
-end
+end

data/spec/core/module/const_get_spec.rb

@@ -26,9 +26,9 @@ describe "Module#const_get" do
   end
 
   it "searches parent scopes of classes and modules" do
-    ConstGetSpecs::Bar::Baz.const_get(:BAZ).should eq(300)
-    ConstGetSpecs::Bar::Baz.const_get(:BAR).should eq(200)
-    ConstGetSpecs::Bar::Baz.const_get(:FOO).should eq(100)
-    ConstGetSpecs::Bar::Baz.const_get(:Bar).should eq(ConstGetSpecs::Bar)
+    ConstGetSpecs::Bar::Baz.const_get(:BAZ).should == 300
+    ConstGetSpecs::Bar::Baz.const_get(:BAR).should == 200
+    ConstGetSpecs::Bar::Baz.const_get(:FOO).should == 100
+    ConstGetSpecs::Bar::Baz.const_get(:Bar).should == ConstGetSpecs::Bar
   end
 end

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

@@ -0,0 +1,434 @@
+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
+
+# ModuleSpecs::Nesting[:root_level] = Module.nesting