[ruby-core:112654] [Ruby master Feature#19450] Is there an official way to set a class name without setting a constant?

Issue #19450 has been updated by jeremyevans0 (Jeremy Evans).


ioquatix (Samuel Williams) wrote in #note-22:
> > I haven't yet seen a non-contrived example where overriding name will not work
> 
> Any time you have nested class or modules in an anonymous module, it gets very ugly.

I haven't come across a case where you cannot also define `name` on those nested classes/modules, though it is possible such a case exists.

> > Examples with invalid constant names already show how this feature could easily be abused.
> 
> Already a possible attack surface as demonstrated.

Apologies, it but was not obvious to me where you demonstrated this.  Could you link to where you think you already demonstrated this?

It's true that you can define `name` to return an invalid constant name, but doing so does not currently automatically infect nested modules.

> > due to how rarely this feature is needed
> 
> Since this feature doesn't exist yet, I don't think you can argue that it's rarely used.

The rarity I'm referring to is the need to define a name for an anonymous class or module without assigning it to a constant.  My guess would be at somewhere between 1% and 0.1% of anonymous classes and modules need to override  `name`.  Are you of the opinion that the need to assign a name to an anonymous module or class without assigning it to a constant is more common than 1%?

> As stated above, a similar feature is used over 100 times in Ruby's own test suite. Other anecdotal evidence suggests this is a fairly common issue as there are a variety of blog posts and SO answers about various ways to achieve it (i.e. overriding `#name`). I've enumerated several key places where I wished this interface existed. However, as stated, overriding `#name` is insufficient for nested classes/modules.

For the anonymous classes/modules currently overriding `name`, this feature would be helpful, I said that up front.  In my experience, there is only a small percentage of cases where `{Class,Module}.new` is used and `name` is also overridden.
 
> I don't see why "rarity of usage" (which is yet to be proven) is a strong argument for "bespoke method names". Can you explain why those two things are related? Are you concerned something is going to break?

In my opinion, it's a bad idea to add positional arguments for things that are rarely needed.  For one, it makes adding future positional arguments much more cumbersome.  This is especially true if the methods already take optional positional arguments, as `Class.new` does.

For arguments that are rarely needed, keyword arguments are better.  For one, use of a positional argument for the temporary name in `Class.new` means that you must manually specify `Object` as the first argument, even in cases where it would be the default.

So if we had to accept changes to `Module.new` and `Class.new` for temporary names, I think it would be better to use keyword arguments:

```ruby
Class.new(Array, name: 'Foo')
Class.new(name: 'Foo')
Module.new(name: 'Foo')
```

I still think that based on the rarity of need, it would be better to have a separate method:

```ruby
Class.labeled_class('Foo', Array)
Class.labeled_class('Foo')
Module.labeled_module('Foo')
```

The decision of whether to add a keyword argument to an existing method or instead add an additional method is always a judgement call.  Adding a keyword argument makes the method API more complex, especially in cases where the method does not already use keyword arguments.  For cases where it would be somewhat common to use the keyword argument, I think adding a keyword argument makes sense.  However, for cases where using the keyword would be rare, I think 2 separate methods, both with a simpler API, may be better than 1 method with a more complex API.

----------------------------------------
Feature #19450: Is there an official way to set a class name without setting a constant?
https://bugs.ruby-lang.org/issues/19450#change-102102

* Author: ioquatix (Samuel Williams)
* Status: Open
* Priority: Normal
----------------------------------------
This is the best I could come up with:

```ruby
klass = Class.new

Object.const_set("Klass", klass)
Object.send(:remove_const, "Klass")

puts klass.new
# => #<Klass:0x0000000100a9d688>
```

Can we do better?

What about something like:

```ruby
Class.new(name: "Klass")
```

or

```ruby
Class.new do
  def self.name
    "Klass"
  end
end
```

etc



-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/