From: "sawa (Tsuyoshi Sawada)" <noreply@...>
Date: 2022-07-01T16:13:09+00:00
Subject: [ruby-core:109111] [Ruby master Feature#17753] Add Module#namespace

Issue #17753 has been updated by sawa (Tsuyoshi Sawada).


ioquatix (Samuel Williams) wrote in #note-21:
> ```ruby
> class A::B::C::MyClass; end
> 
> A::B::C::MyClass.name(0) # -> "MyClass"
> A::B::C::MyClass.name(1) # -> "C::MyClass"
> A::B::C::MyClass.name(-1) # -> "A::B::C"
> A::B::C::MyClass.name(-2) # -> "A::B"
> ```

What is the rule behind what the argument represents? To me, your four examples except for the first one seem to suggest:

1. The nesting levels (achieved by separating the full name  by `::`) can be referred to by an index as if they were placed in an array. 
2. a. If the argument is negative, then remove the nesting levels from the one indexed by the argument up to the last one.
 b. If the argument is non-negative, then remove the nesting levels from the first one up to the one indexed by the argument.
3. Join the remaining nesting levels with `::`.

But, then I would expect:

```ruby
A::B::C::MyClass.name(0) # -> "B::C::MyClass"
```

contrary to what you wrote.

What is your intended logic? Is it coherent? And does that provide a way to get `"B::C::MyClass"`?

----------------------------------------
Feature #17753: Add Module#namespace
https://bugs.ruby-lang.org/issues/17753#change-98258

* 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: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>