Question

I find my self repeating things a lot when I create classes in ruby, often I will end up with something similar to the following:

class Foo
  attr_reader :bar_0,
              :bar_1,
                 .
                 .
                 .
              :bar_n
  def initialize( bar_0 = something,
                  bar_1 = something,
                        .
                        .
                        .
                  bar_n = something)
    @bar_0 = bar_0
    @bar_1 = bar_1
           .
           .
           .
    @bar_n = bar_n
  end
end

Does ruby employ a shortcut for more efficiently implementing something like this?

Answer 1

Judging from the way the question is phrased, you should probably rethink the design of your classes. However, Ruby provides an interesting way to quickly create classes with attr_accessors (not readers). Here’s a simple example:

>> class Person < Struct.new(:name, :age) ; end
=> nil
>> p = Person.new
=> #<struct Person name=nil, age=nil>
>> p.age = 23
=> 23
>> p.class
=> Person
>> p.methods.grep(/age/)
=> [:age, :age=]

Of course this is a normal class and you can add all the methods you want (and use getters and setters instead of instance variables, e.g. var for the getter and self.var = foo for the setter).

If you really don’t want the writers, make them private or undef them.

>> attrs = [:name, :age]
=> [:name, :age]
>> class Person < Struct.new *attrs ; end
=> nil
>> Person.instance_eval { private *attrs.map{|attr| "#{attr}=" }}
=> Person
>> p = Person.new
=> #<struct Person name=nil, age=nil>
>> p.methods.grep(/age/)
=> [:age]

All of the above doesn’t help with the tons of assignments in initialize of course, but then one wonders if you really want to many constructor arguments or if maybe you just have one hash argument and merge that into a default hash.