Model person (user) profile attributes / properties - best practice, static vs dynamic properties - ruby-on-rails

Question

I couldn't easily find a relevant topic on SO so here we go - a classic problem: I have a User or Person model and I want to model that person's physical properties/attributes (eye color, hair color, skin color, gender, some lifestyle properties like sleep time per night (<8h, ~8h, >8h), smoking, daily sun exposure etc.
I usually solve that problem by creating a separate rails model (database table) for each property because then it is easy to add more options later, edit them, use as a source for <select>, i.e.
class Person
belongs_to :eye_color
belongs_to :skin_color
belongs_to :hair_color
belongs_to :sleep_per_night
belongs_to :sun_exposure
attr_accessible :gender # boolean, m/f
end
class HairColor
has_many :people
attr_accessible :value
end
class EyeColor
has_many :people
attr_accessible :value
end
Person.last.eye_color
...
EyeColor.first.people
But what if there is a lot of those attributes (i.e. 10-15 different phisycal and lifestyle properties). For me it seems like breaking DRY rule, that is, I'm left with many small tables, like eye_colors, which have 3-5 records. Each of those tables has only one meaningful column - value.
I was thinking how you guys solve those problems, maybe by creating a single model, i.e. PersonProperty that has the following structure
person_properties[type, value]
so the previous solution with separate models, i.e. for eye_color and hair_color would look like this (types/classes and values):
# PersonProperty/person_properties:
1. type: 'HairColor', value: 'red'
2. type: 'HairColor', value: 'blond'
3. type: 'SkinColor', value: 'white'
4. type: 'EyeColor', value: 'green'
5. type: 'HairColor', value: 'black'
6. type: 'SkinColor', value: 'yellow'
7. type: 'SleepPerNight', value: 'less than 8h'
8. type: 'SleepPerNight', value: 'more than 8h'
9. type: 'DailySunExposure', value: 'more than 1h'
...
19. type: 'EyeColor', value: 'blue'
...
The above example might be more normalized by splitting the PersonProperty model into two. Or maybe you suggest something else?

Answer 1

I wouldn't suggest a has_one relationship in this case. A User could belongs_to :eye_color, so you can map eyecolors across your users. An EyeColor has_many :users, so that you can do #eye_color.users and get all users with a specific EyeColor. Otherwise you will have to create an EyeColor for every user (or at least the ones with eyes).
The reason I'd suggest this over your PersonProperty solution is because it's easier to maintain and because of the performance gain of delegating these kinds of relations to your database.
UPDATE: If dynamic attributes are what you want, I'd suggest to setup your models like this:
class Person < ActiveRecord::Base
has_many :person_attributes
attr_accessible :gender
accepts_nested_attributes_for :person_attributes
end
class PersonAttribute < ActiveRecord::Base
belongs_to :person_attribute_type
belongs_to :person_attribute_value
belongs_to :person
attr_accessible :person_id, :person_attribute_value_id
end
class PersonAttributeValue < ActiveRecord::Base
has_many :person_attributes
belongs_to :person_attribute_type
attr_accessible :value, :person_attribute_type_id
end
class PersonAttributeType < ActiveRecord::Base
has_many :person_attribute_values
attr_accessible :name, :type
end
This way you can do the following:
#person_attribute_type = PersonAttributeType.create(:name => 'Eye color', :type => 'string')
['green', 'blue', 'brown'].each do |color|
#person_attribute_type.person_attribute.values.build(:value => color)
end
#person_attribute_type.save
#person = Person.new
#person_attribute = #person.person_attributes.build
#person_attribute.person_attribute_value = #person_attribute_type.person_attribute_values.find(:value => 'green')
Of course, you probably won't fill your database through the command line. You will probably be very curious as to how this would work in a form:
class PersonController
# ...
def new
#person = Person.new
PersonAttributeType.all.each do |type|
#person.person_attributes.build(:person_attribute_type = type)
end
end
def create
#person = Person.new(params[:person])
if #person.save
# ...
else
# ...
end
end
def edit
#person = Person.find(params[:id])
PersonAttributeType.where('id NOT IN (?)', #person.person_attributes.map(&:person_attribute_type_id)).each do |type|
#person.person_attributes.build(:person_attribute_type = type)
end
end
# ...
Now the form, based on Formtastic:
semantic_form_for #person do |f|
f.input :gender, :as => :select, :collection => ['Male', 'Female']
f.semantic_fields_for :person_attributes do |paf|
f.input :person_attribute_value, :as => :select, :collection => paf.object.person_attribute_type.person_attributes_values, :label => paf.object.person_attribute_type.name
end
f.buttons
end
Mind that this all is untested, so just try to understand what I'm trying to do here.
BTW, I now realize that the class name PersonAttribute is probably a bit unlucky, because you will have to accepts_nested_attributes_for :person_attributes which would mean you would have to attr_accessible :person_attributes_attributes, but you get my drift I hope.