How to move this to a base class, its a Ruby enumeration - ruby-on-rails

Question

I read this article that explained how to make enumerations in Ruby, and also showed how to them enumerable like:
class Blah
def Blah.add_item(key, value)
#hash ||= {}
#hash[key] = value
end
def Blah.const_missing(key)
#hash[key]
end
def Blah.each
#hash.each {|key, value| yield(key, value)}
end
end
I have other enumerations that I need, can I create a base class somehow from this so I don't have to repeat the methods add_item, const_missng and .each for each one?
When creating a file for all my enums, I put it in /lib/enums.rb, is that a good practise?
should I be putting this class inside of a module i.e. I believe you do that for a namespace right?

Answer 1

You can just use Blah as your base class.
class C < Blah; end
class D < Blah; end
I think I might just throw it in with the source code of each project it's used with. Yes, DIE, DRY, and all that, but that's mostly important in line-by-line code. It's a fairly common practice to merge external software with each project.
No. It's already a class, so it's using only one name. Put the module around the code that uses Blah, the project or section of a project. That will be large and more in need of namespacing.

Answer 2

DigitalRoss's answer is good. I'll present an alternative. Suppose you'd like each of your enumerations to live in a module. All you need is a little Enumeration module, like so:
module Enumeration
include Enumerable
def self.included(m)
m.extend self
end
def each(&block)
constants.find_all do |name|
name =~ /^[A-Z_\d]+$/
end.map do |name|
[name, const_get(name)]
end.sort_by(&:last).each(&block)
end
end
When you need an enumeration, create a module for it, include Enumeration, and define your keys and values as constants with all-caps names.
module States
include Enumeration
INIT = 1
RUN = 2
DONE = 3
end
The module will respond to any of the methods provided by Enumerable:
p States.to_a
# => [["INIT", 1], ["RUN", 2], ["DONE", 3]]
You may find that you sometimes don't care what the values are, just that they are distinct. Let's add to Enumeration a method value that makes it easy to create constants with auto-incrementing keys:
module Enumeration
def value(name, value = next_value)
const_set(name, value)
end
def next_value
(map(&:last).max || 0) + 1
end
end
Now let's have some planets:
module Planets
include Enumeration
value :MERCURY
value :VENUS
value :EARTH
end
p Planets.to_a
# => [["MERCURY", 1], ["VENUS", 2], ["EARTH", 3]]
Of course, these enumerations are just collections of normal constants, so you can use them directly:
p Planets::MERCURY # => 1