Turning constructor arguments into instance variables

Question

Possible Duplicate:
Idiomatic object creation in ruby

There are many occaisions when I have an initialize method that looks like this:

class Foo  
    def initialize bar, buz, ...
        @bar, @buz, ... = bar, buz, ...
    end
end

Is there a way to do this with a simple command like:

class Foo
    attr_constructor :bar, :buz, ...
end

where the symbols represent the name of the instance variables (with the spirit/flavor of attr_accessor, attr_reader, attr_writer)?

I was wondering if there is a built in way or a more elegant way of doing something like this:

class Class
    def attr_constructor *vars
        define_method("initialize") do |*vals|
            vars.zip(vals){|var, val| instance_variable_set("@#{var}", val)}
        end
    end
end

so that I can use it like this:

class Foo
    attr_constructor :foo, :bar, :buz
end

p Foo.new('a', 'b', 'c')      # => #<Foo:0x93f3e4c @foo="a", @bar="b", @buz="c">
p Foo.new('a', 'b', 'c', 'd') # => #<Foo:0x93f3e4d @foo="a", @bar="b", @buz="c">
p Foo.new('a', 'b')           # => #<Foo:0x93f3e4e @foo="a", @bar="b", @buz=nil>

I think this question's been asked before, but I haven't found any exact duplicates. — Andrew Grimm, Oct 21 '11 at 04:57
@AndrewGrimm Thanks for referring to the duplicate question. I will see the answers there. I will vote to close this myself. — sawa, Oct 23 '11 at 05:36

Alex Peattie · Answer 1 · 2011-10-21T03:58:28.360

3

I'd use OpenStruct:

require 'ostruct'

class Foo < OpenStruct
end

f = Foo.new(:bar => "baz")
f.bar
#=> "baz"

Edit: Ah OK, sorry misunderstood you. How about just:

class Foo   
  def initialize(*args)
    @baz, @buz = args
  end
end

edited Oct 21 '11 at 03:58

answered Oct 21 '11 at 03:27

Alex Peattie

26,633
5
50
52

In your code, you need to specify the name of the instance variable at construction, which is worse than just defining that in the `initialize` method. – sawa Oct 21 '11 at 03:36
The edit looks very elegant, but it doesn't seem to work for me. *f.baz* etc throws errors. – bioneuralnet Oct 21 '11 at 04:08
1

You need to add attr_accessor if you want the attribute to read/writable externally, just like normal – Alex Peattie Oct 21 '11 at 04:30

score 2 · Answer 2 · answered Oct 21 '11 at 03:19

2

Would this work for you?

class Foo  
    def initialize(hash)
        hash.each { |k,v| instance_variable_set("@#{k}", v) }
    end
end

answered Oct 21 '11 at 03:19

Moiz Raja

5,612
6
40
52

That is not exactly what I want. I want a class method to be used once in the class body, which controlls the behaviour of `initialize`. – sawa Oct 21 '11 at 03:23

bioneuralnet · Answer 3 · 2011-10-21T04:18:11.777

Interesting question. A little meta-programming should take care of it.

module Attrs
  def self.included(base)
    base.extend ClassMethods
    base.class_eval do
      class << self
        attr_accessor :attrs
      end
    end
  end

  module ClassMethods
    # Define the attributes that each instance of the class should have
    def has_attrs(*attrs)
      self.attrs = attrs
      attr_accessor *attrs
    end
  end

  def initialize(*args)
    raise ArgumentError, "You passed too many arguments!" if args.size > self.class.attrs.size
    # Loop through each arg, assigning it to the appropriate attribute (based on the order)
    args.each_with_index do |val, i|
      attr = self.class.attrs[i]
      instance_variable_set "@#{attr}", val
    end
  end
end

class Foo
  include Attrs
  has_attrs :bar, :buz
end

f = Foo.new('One', 'Two')
puts f.bar
puts f.buz

Of course the downside to this is inflexibility - you have to pass your constructor arguments in a specific order. Of course that's how most programming languages are. Rails people might argue you should instead do

f = Foo.new(:bar => 'One', :baz => 'Two')

which would allow you to pass in attrs in any order, as well as strip away most of the meta-programming. But that is a lot more to type.

Thanks for the answer, but the necessity of writing the line `include Attrs` every time seems to be unpleasant to me. And, I do not necessarily need `attr_accessor`s. — sawa, Oct 21 '11 at 04:39

Turning constructor arguments into instance variables

3 Answers3

Linked