Link method argument to a variable - ruby-on-rails

Question

I have a program where a user is able to receive popular "vacation spots". Al they have to do is enter the continent (Which will bring them to that dictionary) and then enter a country/state (which is a key in a hash) and then it will find the corresponding value.
I have a required file (dict.rb) which is basically a hash module using arrays.
But the issue I have is fairly small. I assigned the user input to two variables, continent_select and country_select
Here's the code:
require './dict.rb'
#create a new dictionary called northamerica
northamerica = Dict.new
Dict.set(northamerica, "new york", "New York City")
Dict.set(northamerica, "new jersey", "Belmar")
puts "Welcome to The Vacation Hub"
puts "What continent are you interested in?"
print '> '
continent_select = $stdin.gets.chomp.downcase
continent_select.gsub!(/\A"|"\Z/, '')
puts "Which state would you like to go to in #{continent_select}"
print '> '
country_select = $stdin.gets.chomp.downcase
#puts "You should go to #{Dict.get(northamerica, "#{country_select}")}"
#=> You should go to Belmar
puts "You should go to #{Dict.get(continent_select, "#{country_select}")}"
#=> error
Ignore the get and set methods, they're in the included dict.rb
Anyway look carefully at the last few lines. The Dict.get method has two arguments. The first finds which dictionary to use. If I just put northamerica as an argument it works. But if I put continent_select instead (assuming the user enters 'northamerica') it doesn't work. I think the program is looking for a Dictionary named continent_select, rather than looking for the variable continent_select.
UPDATE
Here's the whole dict.rb for those who asked.
module Dict
#creates a new dictionary for the user
def Dict.new(num_buckets=256)
#initializes a Dict with given num of buckets
#creates aDict variable which is an empty array
#that will hold our values later
aDict = []
#loop through 0 to the number of buckets
(0...num_buckets).each do |i|
#keeps adding arrays to aDict using push method
aDict.push([])
end
return aDict
#returns [[],[],[]] => array of empty arrays reading to go.
end
def Dict.hash_key(aDict, key)
# Given a key this will create a number and then convert
# it to an index for the aDict's buckets.
return key.hash % aDict.length
#key.hash makes the key a number
# % aDict.length makes the number between 1 and 256
end
def Dict.get_bucket(aDict, key)
#given a key, find where the bucket would go
#sets the key to a number and it's put in bucket_id variable
bucket_id = Dict.hash_key(aDict, key)
#finds the key number in the dict, and returns the key
return aDict[bucket_id]
end
def Dict.get_slot(aDict, key, default=nil)
#returns the index, key, and value of a slot found in a bucket
#assigns the key name to the bucket variable
bucket = Dict.get_bucket(aDict, key)
bucket.each_with_index do |kv, i|
k, v = kv
if key == k
return i, k, v
#returns index key was found in, key, and value
end
end
return -1, key, default
end
def Dict.get(aDict, key, default=nil)
#Gets the value in a bucket for the given key, or the default
i, k, v = Dict.get_slot(aDict, key, default=default)
return v
end
def Dict.set(aDict, key, value)
#sets the key to the value, replacing any existing value
bucket = Dict.get_bucket(aDict, key)
i, k, v = Dict.get_slot(aDict, key)
if i >= 0
bucket[i] = [key, value]
else
bucket.push([key, value])
end
end
def Dict.delete(aDict, key)
#deletes. the given key from the Dict
bucket = Dict.get_bucket(aDict, key)
(0...bucket.length).each do |i|
k, v = bucket[i]
if key == k
bucket.delete_at(i)
break
end
end
end
def Dict.list(aDict)
#prints out what's in the dict
aDict.each do |bucket|
if bucket
bucket.each {|k, v| puts k, v}
end
end
end
end

Answer 1

Now there's some weird stuff going on.
In the first case, which seems to be okay, you pass the correct arguments:
Dict.get(northamerica, "#{country_select}")
That is: Dict instance as the first argument, and a String as the second. But then in the second case:
Dict.get(continent_select, "#{country_select}")
You pass a String instance instead of an obviously expected Dict, and this results in an error.
As far as I understand your intention, you want user input to become a variable name to be used as the first argument, but there is no way way it is magically happening, and you end you up passing just a string.
What you need to do is explicitly map a user input to a corresponding Dict object, and then use it. It can look like this:
# fetch a Dict object that corresponds to "northamerica" string from a hash
# NOTE: it will raise an exception if a user enters something that's not present
# in a hash, i.e. something other than "northamerica"
selected_continent_dict = { "northamerica" => northamerica }.fetch(continent_select)
puts "You should go to #{Dict.get(selected_continent_dict, country_select)}"
If you're prohibited to use Ruby hashes, you can easily get away with a case statement:
selected_continent_dict = case continent_select
when "northamerica"
northamerica
else
raise "Invalid continent"
end
puts "You should go to #{Dict.get(selected_continent_dict, country_select)}"
Hope this helps!
P.S. Two more advice, if you don't mind:
There's no real need for string interpolation in the second argument, and something like Dict.get(northamerica, country_select) could be a cleaner way.
Better variable naming could save you from headaches. I.e. if you renamed a (quite misleading) country_select to a user_state_selection_string it would remind you that it is a string, and of what it holds. The example is arbitrary though. There's a wonderful book called "Code Complete" by Steve McConnell which covers this and other issues much better than I do.