[ruby-core:113355] [Ruby master Feature#19520] Support for `Module.new(name)` and `Class.new(superclass, name)`.

27 Apr 2023

      Issue #19520 has been updated by Dan0042 (Daniel DeLorme).

I also really want the ability to give better names to dynamically created classes. In particular for something that is created once via a registry, like `x = MyTemplate["path/to/file"]`, having `x.new.bad` produce an error like "undefined method 'bad' for #<MyTemplate["path/to/file"]>:0x000055e017895038>" is super useful, because you can type `MyTemplate["path/to/file"]` in irb and get the correct class; even if it's not a constant name, it's still eval'able.

But I think the idea of changing #name is something like a X Y problem. The problem X is that we need a more useful #inspect for instances, and the perceived solution Y is to change the value of #name of the class, but there are other ways too. Changing only #inspect or #to_s on the class would be enough, as long as they are used where needed.

```ruby
x = Class.new
def x.to_s; "(x.to_s)"; end
def x.inspect; "(x.inspect)"; end
x.ancestors   #=> [(x.inspect), Object, Kernel, BasicObject]
x.new.inspect #=> #<#<Class:0x00005651b7e5f830>:0x00005651b8448968>
```

The #inspect above would be more helpful if it was "#<(x.to_s):0x00005651b8448968>", and the problem here is that the default Object#inspect displays the class with builtin `rb_class_name` which ignores the #to_s and #inspect methods defined for the class. I think a good solution here would be to have `rb_class_name` try to call #to_s, and maybe resort to a failsafe if the result of #to_s is invalid (too long, etc).

Basically what I'm saying is that there are ways to solve this problem without changing the semantics of #name.

----------------------------------------
Feature #19520: Support for `Module.new(name)` and `Class.new(superclass, name)`.
https://bugs.ruby-lang.org/issues/19520#change-102916

* Author: ioquatix (Samuel Williams)
* Status: Open
* Priority: Normal
----------------------------------------
See <https://bugs.ruby-lang.org/issues/19450> for previous discussion and motivation.

[This proposal](https://github.com/ruby/ruby/pull/7376) introduces the `name` parameter to `Class.new` and `Module.new`:

```ruby
Class.new(superclass, name)
Module.new(name)
```

As a slight change, we could use keyword arguments instead.

## Example usage

The current Ruby test suite has code which shows the usefulness of this new method:

```ruby
  def labeled_module(name, &block)
    Module.new do
      singleton_class.class_eval {
        define_method(:to_s) {name}
        alias inspect to_s
        alias name to_s
      }
      class_eval(&block) if block
    end
  end
  module_function :labeled_module

  def labeled_class(name, superclass = Object, &block)
    Class.new(superclass) do
      singleton_class.class_eval {
        define_method(:to_s) {name}
        alias inspect to_s
        alias name to_s
      }
      class_eval(&block) if block
    end
  end
  module_function :labeled_class
```

The updated code would look like this:

```ruby
  def labeled_module(name, &block)
    Module.new(name, &block)
  end

  def labeled_class(name, superclass = Object, &block)
    Class.new(superclass, name, &block)
  end
  module_function :labeled_class
```

-- 
https://bugs.ruby-lang.org/