opal-cj 0.7.0.beta1

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,8 @@
+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/module/alias_method_spec.rb

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,85 @@
+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)
+    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

@@ -0,0 +1,85 @@
+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

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

@@ -0,0 +1,17 @@
+require File.expand_path('../../fixtures/constants', __FILE__)
+
+describe "Module#const_missing" do
+  it "is called when an undefined constant is referenced via literal form" do
+    ConstantSpecs::ClassA::CS_CONSTX.should == :CS_CONSTX
+  end
+
+  it "is called when an undefined constant is referenced via #const_get" do
+    ConstantSpecs::ClassA.const_get(:CS_CONSTX).should == :CS_CONSTX
+  end
+
+  it "raises NameError and includes the name of the value that wasn't found" do
+    lambda {
+      ConstantSpecs.const_missing("HelloMissing")
+    }.should raise_error(NameError, /ConstantSpecs::HelloMissing/)
+  end
+end

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

@@ -0,0 +1,64 @@
+require File.expand_path('../../fixtures/constants', __FILE__)
+
+module ConstantSpecs
+end
+
+describe "Module#const_set" do
+  it "sets the constant specified by a String or Symbol to the given value" do
+    ConstantSpecs.const_set :CS_CONST401, :const401
+    ConstantSpecs::CS_CONST401.should == :const401
+
+    ConstantSpecs.const_set "CS_CONST402", :const402
+    ConstantSpecs.const_get(:CS_CONST402).should == :const402
+  end
+
+  it "returns the value set" do
+    ConstantSpecs.const_set(:CS_CONST403, :const403).should == :const403
+  end
+
+  # PENDING: needs proper parser implementation
+  #
+  # it "sets the name of an anonymous module" do
+  #   m = Module.new
+  #   ConstantSpecs.const_set(:CS_CONST1000, m)
+  #   m.name.should == "ConstantSpecs::CS_CONST1000"
+  # end
+
+  it "raises a NameError if the name does not start with a capital letter" do
+    lambda { ConstantSpecs.const_set "name", 1 }.should raise_error(NameError)
+  end
+
+  it "raises a NameError if the name starts with a non-alphabetic character" do
+    lambda { ConstantSpecs.const_set "__CONSTX__", 1 }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_set "@Name", 1 }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_set "!Name", 1 }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_set "::Name", 1 }.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_set("CS_CONST404", :const404).should == :const404
+    lambda { ConstantSpecs.const_set "Name=", 1 }.should raise_error(NameError)
+    lambda { ConstantSpecs.const_set "Name?", 1 }.should raise_error(NameError)
+  end
+
+  # PENDING: should_receive isn't available on opal-spec
+  #
+  # it "calls #to_str to convert the given name to a String" do
+  #
+  #   name = mock("CS_CONST405")
+  #   name.should_receive(:to_str).and_return("CS_CONST405")
+  #   ConstantSpecs.const_set(name, :const405).should == :const405
+  #   ConstantSpecs::CS_CONST405.should == :const405
+  # end
+
+  # PENDING: should_receive isn't available on opal-spec
+  #
+  # it "raises a TypeError if conversion to a String by calling #to_str fails" do
+  #   name = mock('123')
+  #   lambda { ConstantSpecs.const_set name, 1 }.should raise_error(TypeError)
+  #
+  #   name.should_receive(:to_str).and_return(123)
+  #   lambda { ConstantSpecs.const_set name, 1 }.should raise_error(TypeError)
+  # end
+end

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

@@ -0,0 +1,49 @@
+module ConstantsSpecsModule
+  MOD_CONST1 = "1"
+  MOD_CONST2 = "2"
+  MOD_CONST3 = "3"
+
+  module Foo
+    FOO = "foo"
+  end
+end
+
+class ConstantsSpecsClass
+  CLASS_CONST1 = "1"
+  CLASS_CONST2 = "2"
+  CLASS_CONST3 = "3"
+end
+
+class SubConstantsSpecsClass < ConstantsSpecsClass
+  CLASS_CONST4 = "4"
+end
+
+describe "Module#constants" do
+  it "should return constants in global scope when called from Module or Class" do
+    result = Module.constants
+    result.should include("Module", "Object", "TrueClass", "FalseClass", "RUBY_ENGINE")
+    result2 = Class.constants
+    result.should == result2
+  end
+
+  it "should only return constants and child modules defined directly on module" do
+    result = ConstantsSpecsModule.constants
+    result.size.should == 4
+    result.should include("MOD_CONST1", "MOD_CONST2", "MOD_CONST3", "Foo")
+    result = ConstantsSpecsModule::Foo.constants
+    result.size.should == 1
+    result.should include("FOO")
+  end
+
+  it "should only return constants defined directly on class" do
+    result = ConstantsSpecsClass.constants
+    result.size.should == 3
+    result.should include("CLASS_CONST1", "CLASS_CONST2", "CLASS_CONST3")
+  end
+
+  it "should include constants inherited from superclass" do
+    result = SubConstantsSpecsClass.constants
+    result.size.should == 4
+    result.should include("CLASS_CONST4", "CLASS_CONST1", "CLASS_CONST2", "CLASS_CONST3")
+  end
+end

data/spec/opal/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