Ruby: Namespacing of instance methods - ruby

Question

I have TONS of instance methods, all sharing the same instance variables.
Since the class became huge, I split the methods into around 50 modules.
And then the class that is left is including all those 50 modules.
I ended up with an unbelievable ugly code which is full of instance methods like "module_name_method_name" to avoid collisions of method names.
The problem is that each Module might have similar (similar, not same) functionality (in turn similar method names).
My current code looks like this:
The modules:
module Toyota
def toyota_method1;#foo...;end
def toyota_method2;#foo...;end
....
end
module Ford
def ford_method1;#foo...;end
def ford_method2;#foo...;end
....
end
.... around 50 such modules
class Cars
include Toyota
include Ford
include ...
def foo
#foo = "bar"
#bar = "foo"
...
toyota_method1
ford_method2
toyota_method2
...
end
end
How could I design my code better?
The most important thing is that ALL instance methods need to share the same instance variables.. or at least somehow have access to the same data!
EDIT:
I just came up with this myself:
class Toyota
attr_accessor :foo
def method1
puts #foo
end
end
class Ford
attr_accessor :foo
def method1
puts #foo
end
end
class Cars
def foo
#foo = "bar"
toyota = Toyota.new
toyota.foo = #foo
toyota.method1
ford = Ford.new
ford.foo = #foo
ford.method1
end
end
cars = Cars.new
cars.foo
In fact it solves the ugly method name problem, but now I'm dealing with new problems: the variable #foo might be quite large and it's duplicating itself 50 times (or more) into memory (since I have 50 such classes).
Any other solutions?

Answer 1

It's not only duplicating 50 times or more, its duplicated per instance since it's an instance variable. From what I can tell about your code, and you have to correct me if I'm wrong, it would be best for you to use inheritance along with variable sharing on the class level. This may not work if your car class really needs to know all the different methods from all kind of models it might be, but then I would say you've done something inherently wrong from the beginning. So let's look at inheritance:
class Car
attr_accessor :foo
# lets you initialize attributes via a hash
#
def initialize attrs={}
super()
attrs.each do |att, value|
self.send(:"#{att}=", value)
end
end
end
Inherit Toyota from Car:
class Toyota < Car
def method1
# do what you want to do in this method
end
end
Same for Ford:
class Ford < Car
def method1
# do what you want to do in this method
end
end
Like this you won't have to put namespaces in front of your method:
Ford.new(:foo => 'fordfoo').foo #=> will put out «fordfoo»
Toyota.new(:foo => 'toyotafoo').foo #=> will put out «toyotafoo»
Sharing across classes
Now, if foo is Shared across all cars, you can make it either a) a constant on the car class if it is static:
class Car
FOO = 'bar'
def put_foo
puts FOO
end
end
Like this, all Instances of Car, Toyota or Ford will have access to the static constant FOO, which will only exist one time in memory:
Toyota.new.put_foo #=> 'bar'
If foo has to be assignable and only has to exist one time for the whole inheritance tree, use class variables:
class Car
class << self
def foo= data
##foo = data
end
end
def foo= data
self.class.foo = data
end
def foo
##foo
end
end
Now ##foo only exists once for the inheritance tree, so if you do this:
car = Car.new
toyota = Toyota.new
toyota.foo = 'toyota'
car.foo #=> 'toyota'
This can lead to serious problems if you're not paying attention, but if foo must be the same anyway for all classes, it's the way to go. There are also some issues with Thread Safety you will have to address (with Mutex) working with class variables.
If Car, Toyota and Ford all have different foo, but the instances of each class need to share the same foo (so it is 3 foo's in total), use class instance variables:
class Car
class << self
def foo= data
#foo = data
end
def foo
#foo
end
end
def foo= data
self.class.foo = data
end
def foo
self.class.foo
end
end
Like this you will get:
car = Car.new
car.foo = 'bla'
toyota = Toyota.new
toyota.foo #=> is nil
toyota.foo = 'bar'
car.foo #=> still 'bla'
toyota.foo #=> is 'bar'
These are the ways to share the same data across instances.