forget about the view

Which technique do you guys use to enumerate constants where there is a variable name and a “pretty” name?

For example:

But you want them to display as: Guns N' Roses in the view?

I.e., how would you get that proper capitalization, spaces instead of an underscore and an apostrophe, while best honoring “DRY”.

Joe,

I would just use the basic Ruby array literal:

 HAIR_METAL_BANDS = [ "Guns N' Roses", "Mötley Crüe", "Whitesnake", "David Bowie", "Aerosmith", "Bon Jovi", "AC/DC", "Queen" ] 

Dan’s post is usually how we handle that situation here. The main issue with it is that changing the user-visible names would require a migration. We haven’t run into that much, but it’s definitely a valid concern.

Joe,

Don’t use %w here.

1
2
3

  HAIR_METAL_BANDS  = ["Guns N' Roses",
                                             'Poison',
                                             'Def Leppard']

This still kind of sucks because if someone wants to update that display, you’ll have to update your constant and the value in the db for any existing rows.

You can avoid that using something like:

1
2
3
4
5
6
7
8
9
10

   MONSTER_METAL = [0, 1, 2]

   # turn up the radio!!! in a helper
   def display_for(monster_metal)
     metal_mania = {
       0 => 'Autograph',
       1 => 'White Lion',
       2 => 'Bullet Boys'
     }[monster_metal]
   end

Thats ok but you still got 0,1,2 in 2 places.

Here’s a simplified version of the pattern I’m happy with, based on a post from the 37signals blog.

1
2
3
4
5
6
7
8
9
10
11
12
13

RED = 'red'
GREEN = 'green'
BLUE = 'blue'

def self.colors_to_values
  {'fire' => RED, 'grass' => GREEN, 'aqua' => BLUE }
end

validates_inclusion_of :color, :in => self.colors_to_values.values

def self.colors
  colors_to_values.keys
end

I like keeping the final values as constants so it’s even easier to change later, when I decide RED is really #FF0000.

I posted a solution for this very problem here:

http://pastie.caboo.se/82509

And also an explanation (warning! is in spanish :) here:

http://emmanueloga.blogspot.com/2007/06/constantes-enums-y-demas-yerbas-en.html

Greetings!

What about this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Drummer < ActiveRecord::Base
  HAIR_BANDS = {
    "guns_n_roses" => "Guns N' Roses", 
    "motley_crue"  => "Mötley Crüe", 
    "white_snake"  => "Whitesnake",
    "morrisey"     => "Morrisey"
  }
  
  validates_inclusion_of :influence, :in => self.HAIR_BANDS.keys
  
  def humanized_influence
    HAIR_BANDS[influence]
  end
end

Jared, Tammer, sandofsky, and Emmanuel,

I don’t understand what existing problem you’re solving in your comments.

As developers, we acknowledge the inherent trade-off in choosing a constant (“TYPES” in Jared’s original example) rather than an entire model (“EventTypes”):

If the types change after the system is live, it will require a series of decisions about how we handle existing data, the constant, and our UI.

That is a hypothetical scenario, however, because we choose to use a constant only if it is unlikely that the types will change. If we DO expect the types to change, we want to choose another model, acknowledging that the extra database/ActiveRecord costs are worth it given the business requirements.