Match an item to a list of items - ruby

Question

Let's say I want to group States into Regions. For instance, the Southwest Region might be: Texas, Oklahoma, Colorado, New Mexico, Utah, Arizona, Nevada.
Somehow I need to create the list of states and define the region groupings. I also need to be able to lookup a region given the name of a state, something like region_for('Texas') which would return 'Southwest'.
What is the best, cleanest, "Ruby Way" to do something like this? I'd like to do it using plain 'ol ruby, no database or frameworks.

Answer 1

You can almost type this data structure directly into Ruby...
result = {
'Southwest' => %W{Texas Oklahoma Colorado New\ Mexico Utah Arizona Nevada},
'West' => %W{California Oregon Washington},
}.inject({}) do |m, (k, v)|
m[k] = v
v.each { |s| m[s] = k }
m
end
This produces a single Hash that has both states and regions as keys identifying each other. The data structure looks something like:
{"Colorado" => "Southwest",
"New Mexico" => "Southwest",
"Oklahoma" => "Southwest",
"California" => "West",
"Oregon" => "West",
"Texas" => "Southwest",
"Washington" => "West",
"Utah" => "Southwest",
"Nevada" => "Southwest",
"Arizona" => "Southwest"
"Southwest" =>
["Texas", "Oklahoma", "Colorado", "New Mexico", "Utah", "Arizona", "Nevada"],
"West" =>
["California", "Oregon", "Washington"],
}
Another approach would create a separate hash for states. Then you could get a list of regions or states by using Hash#keys, but you could do that here as well by using Enumerable#select or Enumerable#reject based on the type of the value.

Answer 2

The 'pure' ruby way is just to use hashes, and then have keys to do your lookups. There's a gem that kind of does something like this: ruport. It might be worth it to look at the source-code. For the use case you've illustrated, I'd have something like:
class RegionMapper
#potentially put this in a config file
REGIONS = Hash[[['California', 'Southwest'], ...]]
def initialize
#region_map = REGIONS.inject({}) {|r, e| r[e.second] ||= []; r[e.second] << e.first; r}
end
def region_for_state(state)
REGIONS[state]
end
def states_for_region(region)
#region_map(region)
end
end
The point is, to be efficient, you want to have a hash to do the lookups on each key you want to search by. But you dont' want to expose the data-duplication, so you put it all in a class.
If you have multiple values / keys, then you really have a table. If you want to keep constant time lookups, then you build a hash for each column (like the #region_map)

Answer 3

Try:
class State
attr_accessor :name, :region
def initialize(name, region=nil)
#name = name
#region = region
end
end
class Region
attr_accessor :name, :states
def initialize(name, states)
#name = name
#states = states
end
def set_state_regions
self.states.each {|state| state.region = self.name}
end
end
mo = State.new("missouri")
il = State.new("illionois")
oh = State.new("ohio")
midwest = Region.new("midwest", [mo, il, oh])
midwest.states.each {|state| puts state.name}
midwest.set_state_regions
I may come back and reflect on this later, I think it violates some OO principles.

Answer 4

I builded a very similar answer like Caley.
Main difference: I stored my data in a yaml-structure.
require 'yaml'
class Region
##all = {}
def self.[](key)
##all[key]
end
def initialize(name)
#name = name
#states = []
##all[#name] = self
end
def <<(state)
#states << state
state.region = state
end
def each_state
#states.each{|state| yield state } if block_given?
#states
end
attr_reader :name
end
class State
##all = {}
def self.[](key)
##all[key]
end
def initialize(name, region = nil)
#name = name
#region = region
##all[#name] = self
end
attr_accessor :name
attr_accessor :region
end
YAML.load(DATA).each{|region,states|
r = Region.new(region)
states.each{|state| r << State.new(state) }
}
p Region['Southwest Region']
p Region['Southwest Region'].each_state
Region['Southwest Region'].each_state{|state|
p state.name
}
__END__
Southwest Region:
- Texas
- Oklahoma
- Colorado
- New Mexico
- Utah
- Arizona
- Nevada.
Pacific:
- California
- Oregon
- Washington

Answer 5

A Hash is fine, you don't need anything fancier for this.
region = {
"Maine" => "New England",
"New Hampshire" => "New England",
etc
}
Which you then use like
region["Maine"]
Or if you want to set it up more compactly, like this:
regions = {
"Southwest" => ["Texas", "Oklahoma", "Colorado", "New Mexico", "Utah", "Arizona", "Nevada"],
"New England" => ["Maine", "New Hampshire", "Vermont", "Massachusetts","Rhode Island", "Connecticut"],
etc
}
region = {}
regions.each do |r,states|
states.each do |state|
region[state] = r
end
end