Using AI To Improve Ruby Code

I asked chat.openai.com if there was a better way to implement dynamically defined classes in this module.

module Hive
  def self.api_classes
    @api_classes ||= {}
  end

  def self.const_missing(const)
    super unless const.to_s.end_with? 'Api'

    api = api_classes[const]
    api ||= Api.clone(freeze: false) rescue Api.clone
    api.api_name = const
    api_classes[const] = api
  end
end

The reply I got from AI:

It looks like the code you posted is defining a method named `const_missing` that is intended to be used as a callback when Ruby encounters a reference to a constant that hasn't been defined. In this method, the code checks to see if the constant name ends with "Api", and if it does, it attempts to clone an `Api` class and save it in a hash. One possible way to improve this code would be to move the logic for defining a new `Api` class into its own method, and then call that method from `const_missing` instead of duplicating the code. This would make the code easier to read and maintain. For example:

module Hive
  def self.api_classes
    @api_classes ||= {}
  end

  def self.const_missing(const)
    super unless const.to_s.end_with? 'Api'

    define_api_class(const)
  end

  def self.define_api_class(const)
    api = api_classes[const]
    api ||= Api.clone(freeze: false) rescue Api.clone
    api.api_name = const
    api_classes[const] = api
  end
end

Another possible improvement would be to add error handling to the code in case `Api.clone` raises an error. For example, you could add a `rescue` clause to catch any errors and log them, or you could add a check to verify that `Api.clone` returned a valid `Api` class before storing it in the hash. Overall, the exact improvements you make to this code will depend on your specific use case and requirements. I would recommend considering the specific needs of your application and making changes accordingly.

This is a very competent response. If I were interviewing this person, I might hire them.

The AI doesn’t speculate about certain deeper concepts. There’s a reason I call Api.clone(freeze: false) rescue Api.clone. Is a package designer, I want this code to be compatible with Ruby 2.6 through 3.x.

I also asked if there is a better way to cache these cloned classes so I can avoid using a module class variable.

One possible way to avoid using a module class variable to cache the cloned classes in the code you posted would be to use a thread-local variable instead. A thread-local variable is a variable that is local to the current thread, which means that each thread can have its own value for the variable without affecting the values in other threads. To use a thread-local variable in this case, you could modify the code as follows:

module Hive
  def self.const_missing(const)
    super unless const.to_s.end_with? 'Api'

    api_classes[const] ||= begin
      api = Api.clone(freeze: false) rescue Api.clone
      api.api_name = const
      api
    end
  end

  def self.api_classes
    Thread.current[:api_classes] ||= {}
  end
end

In this updated code, the api_classes method uses `Thread.current[:api_classes]` to store the hash of cloned classes. This means that each thread will have its own separate hash of cloned classes, and the values in one thread's hash won't affect the values in other threads' hashes. Using a thread-local variable in this way can be a good alternative to using a module class variable, since it avoids the potential for conflicts and race conditions that can arise when using class variables. However, it's important to note that thread-local variables can also have their own set of drawbacks and limitations, so you should carefully consider your specific use case and requirements before deciding which approach is best for your application.

That’s a great idea. I might even integrate these suggestions. I’m not too proud to accept them from an AI.