Ruby turn values inside a hash into local variables

Question

Say I have this hash:

entry = {"director"=>"Chris Nolan", "producer"=>"Sum Duk", "writer"=>"Saad Bakk"}

I want to extract each key into its own local variable with the associated value:

director = "Chris Nolan"
producer = "Sum Duk"
...

By using a loop and not:

director = entry["director"]

Since there are a lot of values and I don't want to do them individually.

I found this which works almost perfectly except it creates an instance variable and I want a local variable, but local_variable_set doesn't exist for some reason.

entry.each_pair { |k, v| instance_variable_set("@#{k}", v) }

Is there a solution? Or failing that, a way to turn an instance variable into a local one and delete the instance one without doing it one by one?

Answer 1

Option 1

I can't recommend this except for fun, but it mostly has the effect you are after:

entry.each |k, v|
  singleton_class.send(:attr_accessor, k)
  send("#{k}=", v)
end

director                        # => "Chris Nolan"
self.director = "Wes Anderson"  # Unfortunately, must use self for assignment
director                        # => "Wes Anderson"

Instead of creating local variables it defines acccessor methods on the singleton class of the current object, which you can call as if they were local variables.

To make them more "local" you could use singleton_class.remove_method to remove these methods when you are done with them. You could even try to alias any existing singleton class methods with the same name and restore them afterwards.

Option 2

This is something I use in real code. It requires the ActiveSupport gem which comes with Ruby On Rails but can also be used on its own.

director, producer, writer = entry.values_at('director', 'producer', 'writer')

Unfortunately it requires typing each variable name twice, instead of zero times as you asked for. If you were certain about the order of the values in the hash, you could write:

director, producer, writer = entry.values  # Not so good, IMO.

I feel uneasy about this version because now the code that created the hash has a non-obvious responsibility to ensure the hash is in a certain order.

Note

If your goal is just to reduce typing, here is an approach that only requires two more characters per variable access than if they were true local variables:

e = OpenStruct.new(entry)
e.director     # => "Chris Nolan"

Answer 2

You can't create local variables, because of variable scope.
If you create a local variable inside a block, the variable would be only accessible inside the block itself.
Please refer to this question for more info.
Dynamically set local variables in Ruby

Answer 3

You can do this with eval, but all operations on those variables must be inside the scope they were defined in.

For example, this will work:

vals = {
  "foo" => "bar",
  "baz" => "qux"
}

eval <<-EOF
  #{ vals.map {|k, v| "#{k} = \"#{v}\""}.join("\n") }
  puts foo
EOF

However, this will not:

vals = {
  "foo" => "bar",
  "baz" => "qux"
}

eval <<-EOF
  #{ vals.map {|k, v| "#{k} = \"#{v}\""}.join("\n") }
EOF

puts foo

as foo goes out of scope at the end of the eval. However, if all your work on the variables can be done inside the scope of the eval, it's quite doable.

Answer 4

Expanding on @antinome's note: If you want local variables just to exist, because you want to access them dynamically for instance by interpolating them in a String, then OpenStruct + instance_eval offers this powerful way:

require 'ostruct'
o = OpenStruct.new(entry)
o.instance_eval("Directed by #{director}, produced by #{producer}")
o.instance_eval {
  puts "Directed by #{director}"
  puts "Produced by #{producer}"
}