How to create attr_reader to a class dynamically - ruby

Question

How do I create an attribute on an object dynamically and assign an object to its value?
I have the following code:
class Component
def initialize
end
end
class BaseClass
def initialize
end
# define class methods
def self.create_component(**args)
# create attr_accessor with name "ball"
# set ball = Component.new
end
end
class ChildClass < BaseClass
create_component :name => "ball"
create_component :name => "baseball"
def initialize
end
end
My goal is that when the ChildClass calls "create_component" method, this should create an attribute with the name provided in :name parameter and instantiate a "Component" object to this attribute.
object = ChildClass.new
object.ball #=> to return object reference (Component class 1)
object.baseball #=> to return object reference (Component class 2)

Answer 1

You can define BaseClass like so:
class Component; end
class BaseClass
##components = []
def initialize
##components.each do |attr|
instance_variable_set("##{attr}", Component.new)
end
end
def self.create_component(name:)
attr_reader name.to_sym
##components << name
end
end
class ChildClass < BaseClass
create_component :name => "ball"
create_component :name => "baseball"
end
object = ChildClass.new
object.ball
# => #<Component:0x00007fa62fbdf3f8>
object.baseball
# => #<Component:0x00007fa62fbdf3a8>
Basically you do three things:
Create a class-level instance variable ##components which stores a list of the custom attr_reader names
Inside create_component, call attr_reader to create the method and also add it to the ##components list
Inside initialize, set initial values for each of the ##components (you can also give custom values for these using initialize arguments if you like).

Answer 2

You could do that as follows.
class Component
end
class BaseClass
def create_component(name)
self.class.send(:attr_accessor, name)
instance_variable_set("##{name}", Component.new)
end
end
class ChildClass < BaseClass
end
c = ChildClass.new
c.create_component "ball"
#=> #<Component:0x000056f36c73c2e0>
c.create_component"baseball"
#=> #<Component:0x000056f36c7533f0>
c.methods & [:ball, :baseball]
#=> [:ball, :baseball]
c.instance_variables
#=> [:#ball, :#baseball]
c.ball
#=> #<Component:0x000056f36c73c2e0>
c.baseball
#=> #<Component:0x00005602be1eb560>
c.ball = 1
c.ball
#=> 1
Note that
self.class.send(:attr_accessor, name)
could be replaced with
self.class.class_eval { attr_accessor name.to_sym }
That the instance variables are being added to an instance of a child class of BaseClass is of no matter. It would be essentially the same question if they were to be added to an instance of BaseClass.

Answer 3

This creates an instance method, such as:
def baseball
#baseball ||= Component.new
end
For the baseball= it just uses regular attr_writer:
class Component
end
class BaseClass
def self.create_component(name:)
class_eval <<~EOB
attr_writer :#{name}
def #{name}
##{name} ||= Component.new
end
EOB
end
end
class ChildClass < BaseClass
create_component name: "ball"
create_component name: "baseball"
end
This seems to work:
> c = ChildClass.new
> c.ball
=> #<Component:0x00007f8b270cfa58>
> c.baseball
=> #<Component:0x00007f8b270dbdd0>