From: "ioquatix (Samuel Williams)" Date: 2022-07-02T00:03:52+00:00 Subject: [ruby-core:109112] [Ruby master Feature#17753] Add Module#namespace Issue #17753 has been updated by ioquatix (Samuel Williams). ```ruby class Class def name(offset = nil) return super() unless offset parts = super().split('::') if offset >= 0 parts = parts[(parts.size - 1 - offset)..-1] else parts = parts[0...(parts.size + offset)] end return parts.join('::') end end module A module B module C class MyClass end end end end pp A::B::C::MyClass.name(0) # -> "MyClass" pp A::B::C::MyClass.name(1) # -> "C::MyClass" pp A::B::C::MyClass.name(-1) # -> "A::B::C" pp A::B::C::MyClass.name(-2) # -> "A::B" ``` Something like this. ---------------------------------------- Feature #17753: Add Module#namespace https://bugs.ruby-lang.org/issues/17753#change-98259 * Author: tenderlovemaking (Aaron Patterson) * Status: Open * Priority: Normal ---------------------------------------- Given code like this: ```ruby module A module B class C; end class D; end end end ``` We can get from `C` to `B` like `C.outer_scope`, or to `A` like `C.outer_scope.outer_scope`. I want to use this in cases where I don't know the outer scope, but I want to find constants that are "siblings" of a constant. For example, I can do `A::B::C.outer_scope.constants` to find the list of "sibling" constants to `C`. I want to use this feature when walking objects and introspecting. For example: ```ruby ObjectSpace.each_object(Class) do |k| p siblings: k.outer_scope.constants end ``` I've attached a patch that implements this feature, and there is a pull request on GitHub [here](https://github.com/ruby/ruby/pull/4326). ---Files-------------------------------- 0001-Add-Module-outer_scope.patch (5.93 KB) 0001-Add-Module-namespace.patch (5.89 KB) -- https://bugs.ruby-lang.org/ Unsubscribe: