Method For Making Methods: Easy Ruby Metaprogramming

Question

I have a bunch of methods like this in view helper

  def background
    "#e9eaec"
  end
  def footer_link_color
    "#836448"
  end

I'd like these methods exposed to the view, but I'd prefer the helper to be a bit more concise. What's the best way to turn a hash, say, into methods (or something else)?

Answer 1

module MyHelper
  {:background => "#e9eaec", :footer_link_color => "#836448"}.each do |k,v|
    define_method(k) {v}
  end
end

Though I don't think trading this bit of conciseness for the readability of your first approach is necessarily a good idea.

If you want to generalize this, you can add the following method to the Module class:

class Module
  def methods_from_hash(hash)
    hash.each do |k,v|
      define_method(k) {v}
    end
  end
end

And then in your helper call methods_from_hash(:background => ...).

Answer 2

If you create constants in a namespace, then you can easily whip up accessors for those constants:

class Foo

  module Values
    FOO = 1
    BAR = 'bar'
    BAZ = :baz
  end
  include Values

  Values.constants.each do |name|
    define_method(name.downcase) do
      Values.const_get(name)
    end
  end

end

foo = Foo.new
p foo.foo    # => 1
p foo.bar    # => "bar"
p foo.baz    # => :baz

The include Values mixes the constants into Foo for the convenience of Foo's own methods. It is not needed for this pattern to work.

Answer 3

Here is my remix of sepp2k's answer. It's a bit more OO and works even in irb. Not sure whether to patch Object or Hash.

class Hash
  def keys_to_methods()
    each do |k,v|
      self.class.send(:define_method, k,  Proc.new {v});
    end
    length
  end
end

Test code

hash = {:color_one=>"black", :color_two=>"green"}
hash.keys_to_methods
has.color_one # returns black

OpenStruct: thanks to sepp2k again! I didn't know this existed.

Here is yet another version using method_missing

class Hash
  def method_missing(method_id)
    key = method_id.id2name
    if has_key?(key)
      return self[key]
    elsif has_key?(key.to_sym)
      return self[key.to_sym]
    else
      super.method_missing(method_id)
    end
  end
end

hash = {:color_one=>"black", :color_two=>"green"}
hash.color_one

I'm sure I could get the code tighter (if I knew how).

Answer 4

Actually, ruby has something called OpenStruct, which is quite awesome and really useful for when you want hash but do not want to use it like one.

require 'ostruct'

colors = OpenStruct.new({:background => "0x00FF00", :color => "0xFF00FF"})

p colors.background #=> "0x00FF00"