enumerated 1.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea/
+*~

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.rvmrc

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+rvm --create 1.9.2@enumerated
+rvm use 1.9.2@enumerated

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in enumerated.gemspec
+gemspec

data/README.md

@@ -0,0 +1,148 @@
+# Enumerated - yet another enumeration gem for ActiveRecord
+
+Ok, there are few gems that provides enumeration support to Rails ActiveRecord models, but still missing some
+features. The goal of the **Enumerated** gem is not to provide the feature richest enumeration support, but to make it
+useful to use together with selection/drop down lists. So if you need advanced support consider usage of other
+gem, however if you simply need to work with selection lists this gem is for you.
+
+The **Enumerated** gem will provide support to translate enumerated attributes into labels that are shown in
+selection lists on view and into keys which are stored in the database. This decouples the values stored in
+database and those presented to user on view, so you can freely change labels and no database changes are
+required. **I18n** is supported by default.
+
+The enumerated attribute keys are stored in database as strings. If you want to modify enumeration's key simply
+write the migration that will rename appropriate rows. Changing the label doesn't require any modifications
+in database.
+
+## Installation
+
+Add to your Gemfile:
+
+    gem 'enumerated'
+
+## Usage
+
+First you need to define your attributes that will be enumerated:
+
+    create_table :users do |t|
+        t.string :gender
+    end
+
+Next you need to define your enumerations in the model class:
+
+    class User < ActiveRecord::Base
+        enumerated :gender, [ :male, :female ]
+    end
+
+Enumerated attributes are the values that will be stored in the database (as string).
+
+Having declared enumeration you gain access to several methods. At first you can list
+all available enumeration values:
+
+    User.genders        # => [["Male", :male], ["Female", :female]]
+
+Views and controllers will also have access to helper method:
+
+    user_genders        # => [["Male", :male], ["Female", :female]]
+
+By default this helper method will be added to the controller corresponding to the model,
+so in case of ``User`` model the ``user_genders`` method will be added to ``UsersHelper``.
+If you want to declare other module use ``:helper`` parameter in the declaration:
+
+    class User < ActiveRecord::Base
+        enumerated :gender, [ :male, :female ], :helper => ApplicationHelper
+    end
+
+If you do not want the helper method at all use:
+
+    class User < ActiveRecord::Base
+        enumerated :gender, [ :male, :female ], :helper => false
+    end
+
+### Applying and reading enumeration
+
+There are several ways to set and get the value of enumerated attribute:
+
+    user = User.new
+    user.gender = :male
+    user.gender             # => :male
+    user.male?              # => true
+    user.female?            # => false
+    user.gender_label       # => "Male"
+    user.female!            # => :female
+    user.gender_label       # => "Female"
+
+### Labels and I18n
+
+Enumeration labels may be defined in two ways. First is the place where the enumeration is
+declared:
+
+    class User < ActiveRecord::Base
+        enumerated :gender, { :male => "Sir", :female => "Madam" }
+    end
+
+Second, and more preferred way is the localization file:
+
+    en:
+      activerecord:
+        enumerations:
+          user:
+            gender:
+              male: "Sir"
+              female: "Madam"
+
+If labels are not explicitly defined the humanized versions are taken by default. Labels defined
+in ``Hash`` will override those defined in localization file.
+
+## Advanced usage
+
+By default the order of enumeration options returned by the helper methods is unspecified (albeit most probably
+it will match the order of declaration). If you need to define certain order of the labels (eg. on selection list)
+use the ``:order`` parameter:
+
+    User.genders :order => [ :female, :male ]       # => [["Female", :female], ["Male", :male]]
+    user_genders :order => [ :female, :male ]       # => [["Female", :female], ["Male", :male]]
+
+You can also provide alphabetical order:
+
+    User.genders :order => :alphabetical        # => [["Female", :female], ["Male", :male]]
+
+Also you can define which enumeration options you want to method return:
+
+    User.genders :except => [:male]     # => [["Female", :female]]
+    User.genders :only => [:female]     # => [["Female", :female]]
+
+Labels might be overridden:
+
+    User.genders :override => { :male => "Sir" }    # => [["Sir", :male], ["Female", :female]]
+
+*Note that all parameters shown in this section also applies to method defined in helper module.*
+
+## Validation
+
+By default the ``enumerated`` declaration will add the validation for inclusion of the values specified
+in the declaration. It means that by default model won't be valid if enumerated attribute will have value
+other than specified in the ``enumerated`` declaration:
+
+    class User < ActiveRecord::Base
+        enumerated :gender, [:male, :female]
+        # Implicitly adds the following:
+        validates :gender, :inclusion => [nil, '', :male, :female]
+    end
+
+If you want to prevent **Enumerated** gem adding the validation type:
+
+    class User < ActiveRecord::Base
+        enumerated :gender, [:male, :female], :validate => false
+    end
+
+By default **Enumerated** will add ``nil`` value to the array of expected values (in inclusion statement).
+If you do not want to include ``nil`` type:
+
+    class User < ActiveRecord::Base
+        enumerated :gender, [:male, :female], :nillable => false
+    end
+
+## Issues
+
+  * Currently not supporting STI

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/enumerator.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "enumerated/version"
+
+Gem::Specification.new do |s|
+  s.name        = "enumerated"
+  s.version     = Enumerated::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Michal Orman"]
+  s.email       = ["michal.orman@gmail.com"]
+  s.homepage    = "https://github.com/michalorman/enumerated"
+  s.summary     = %q{Yet another enumeration gem for ActiveRecord}
+  s.description = %q{Goal of the Enumerated gem is to provide support to use enumerations on selection/drop down lists.}
+
+  s.rubyforge_project = "enumerated"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rcov"
+  s.add_development_dependency "activesupport", ["~> 3.0.0"]
+  s.add_development_dependency "activerecord", ["~> 3.0.0"]
+  s.add_development_dependency "sqlite3-ruby"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/enumerated.rb

@@ -0,0 +1,93 @@
+require 'active_support'
+require 'active_record'
+
+require 'enumerated/definition'
+
+module Enumerated
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    # Declares that given attribute is enumerated.
+    def enumerated(attr, enums, opts = {})
+      def opts.disabled?(sym)
+        include?(sym) && !self[sym]
+      end
+
+      class_eval do
+        @definitions ||= {}
+        @definitions[attr.to_sym] = Definition.new(self.to_s, attr.to_s, enums)
+      end
+
+      define_helper_methods(attr, opts)
+      define_label_methods(attr)
+      define_bang_methods(attr, enums)
+      apply_validations(attr, enums, opts)
+    end
+
+    private
+
+    def define_helper_methods(attr, opts)
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def self.#{attr.to_s.pluralize}(opts = {})
+          @definitions[:#{attr.to_s}].to_a(opts )
+        end
+        def self.definitions
+          @definitions
+        end
+      EOS
+
+      unless opts.include?(:helper) && !opts[:helper]
+        helper = opts[:helper] || "#{self.to_s.pluralize}Helper"
+        if helper.is_a?(Module) || Object.const_defined?(helper.to_sym, false)
+          helper = helper.constantize unless helper.is_a?(Module)
+          helper.class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+            def #{self.to_s.underscore}_#{attr.to_s.pluralize}(opts = {})
+              #{self.to_s}.#{attr.to_s.pluralize}(opts)
+            end
+          EOS
+        end
+      end
+    end
+
+    def define_label_methods(attr)
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def #{attr.to_s}_label
+          return nil unless self.class.definitions.include?(:#{attr.to_s}) && !#{attr}.blank?
+          self.class.definitions[:#{attr.to_s}].label(#{attr})
+        end
+      EOS
+    end
+
+    def define_bang_methods(attr, enums)
+      keys(enums).map(&:to_sym).each do |e|
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{e}?
+            #{attr}.to_sym == :#{e}
+          end
+          def #{e}!
+            self.#{attr} = :#{e}
+          end
+        EOS
+      end
+    end
+
+    def keys(collection)
+      collection.is_a?(Array) ? collection : collection.keys
+    end
+
+    def apply_validations(attr, enums, opts)
+      unless opts.disabled?(:validate)
+        inclusion = opts.disabled?(:nillable) ?
+            "#{keys(enums).map(&:to_sym).to_s} + #{keys(enums).map(&:to_s).to_s}" :
+            "[nil, ''] + #{keys(enums).map(&:to_sym).to_s} + #{keys(enums).map(&:to_s).to_s}"
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          validates :#{attr.to_s}, :inclusion => #{inclusion}
+        EOS
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Enumerated)

data/lib/enumerated/definition.rb

@@ -0,0 +1,68 @@
+module Enumerated
+
+  # Wraps single enumerated definition declared in model.
+  class Definition
+
+    def initialize(model, attribute, declaration)
+      @model, @attribute, @declaration = model, attribute, declaration
+      raise ArgumentError, "Declared enumeration must be either Array or Hash." unless declaration.is_a?(Array) || declaration.is_a?(Hash)
+    end
+
+    def to_a(opts = {})
+      result = filtered for_select, opts
+      result = overridden result, opts
+      ordered result, opts
+    end
+
+    def label(key)
+      @declaration.is_a?(Hash) ? @declaration[key.to_sym] : resolve_label(key)
+    end
+
+    private
+
+    def resolve_label(key)
+      I18n.t key.to_s, :default => key.to_s.humanize, :scope => %w(activerecord enumerations) + [@model.downcase, @attribute]
+    end
+
+    def for_select
+      return @declaration.invert.to_a if @declaration.is_a?(Hash)
+      result = []
+      @declaration.each do |d|
+        result << [resolve_label(d), d]
+      end
+      result
+    end
+
+    def ordered(arr, opts)
+      return arr if opts.empty? || !opts.include?(:order)
+      ordered = []
+      opts[:order].each do |o|
+        ordered << arr.select { |a| a[1].to_sym == o.to_sym }[0]
+      end
+      ordered
+    end
+
+    def filtered(arr, opts)
+      return arr if opts.empty? || !(opts.include?(:except) || opts.include?(:only))
+      raise ArgumentError, "Cannot pass both :except and :only parameters!" if opts.include?(:except) && opts.include?(:only)
+      opts.include?(:except) ? except(arr, opts[:except]) : only(arr, opts[:only])
+    end
+
+    def except(arr, keys)
+      arr.reject { |a| keys.map(&:to_sym).include?(a[1].to_sym) }
+    end
+
+    def only(arr, keys)
+      arr.select { |a| keys.map(&:to_sym).include?(a[1].to_sym) }
+    end
+
+    def overridden(arr, opts)
+      return arr if opts.empty? || !opts.include?(:override)
+      opts[:override].each do |key, value|
+        arr.select { |a| a[1].to_sym == key.to_sym }[0][0] = value
+      end
+      arr
+    end
+  end
+
+end

data/lib/enumerated/version.rb

@@ -0,0 +1,3 @@
+module Enumerated
+  VERSION = "1.0.1"
+end

data/spec/dog_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Dog do
+
+  context "when not assigned a name" do
+    before(:each) { subject.valid? }
+
+    it { should_not be_valid }
+    its(:errors) { should_not be_empty }
+    its(:errors) { should have(1).error_on(:name)}
+  end
+
+  context "when assigned a name" do
+    before(:each) { subject.max!; subject.valid? }
+
+    it { should be_valid }
+    its(:name) { should == :max }
+    its(:errors) { should be_empty }
+  end
+
+  context "when assigned an invalid name" do
+    before(:each) { subject.name = :woof; subject.valid? }
+
+    it { should_not be_valid }
+    its(:errors) { should_not be_empty }
+    its(:errors) { should have(1).error_on(:name)}
+  end
+
+  context "when assigned a blank name" do
+    before(:each) { subject.name = ""; subject.valid? }
+
+    its(:name) { should == "" }
+    it { should_not be_valid }
+    its(:errors) { should_not be_empty }
+    its(:errors) { should have(1).error_on(:name)}
+  end
+
+end

data/spec/fixtures/helpers.rb

@@ -0,0 +1,3 @@
+module UsersHelper; end
+
+module HairsHelper; end

data/spec/fixtures/models.rb

@@ -0,0 +1,13 @@
+require 'fixtures/helpers'
+
+I18n.load_path << File.join(File.dirname(__FILE__), '..', 'locales', 'en.yml')
+
+class User < ActiveRecord::Base
+  enumerated :gender, [:male, :female]
+  enumerated :hair, {black: "Black hair", brown: "Brown hair", red: "Red hair", blond: "Blond hair"}, :helper => HairsHelper, :validate => false
+  enumerated :nationality, %w(gbr esp pol), :helper => false
+end
+
+class Dog < ActiveRecord::Base
+  enumerated :name, %w(max sam), :nillable => false
+end

data/spec/hairs_helper_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe HairsHelper do
+  it { should have_defined_method :user_hairs }
+  it { should_not have_defined_method :user_genders }
+  it { should_not have_defined_method :user_nationalities }
+
+  context "should include method" do
+    subject { Class.new { include HairsHelper }.new }
+
+    its(:user_hairs) { should == [["Black hair", :black], ["Brown hair", :brown], ["Red hair", :red], ["Blond hair", :blond]] }
+  end
+
+  context "parametrized" do
+    subject { Class.new { include HairsHelper }.new }
+
+    it "should return user hairs in brown, black, blond, red order" do
+      subject.user_hairs(:order => %w(brown black blond red)).should == [["Brown hair", :brown], ["Black hair", :black], ["Blond hair", :blond], ["Red hair", :red]]
+    end
+
+    it "should return user hairs except brown, black and blond" do
+      subject.user_hairs(:except => %w(brown black blond)).should == [["Red hair", :red]]
+    end
+
+    it "should return only blond, red user hairs" do
+      subject.user_hairs(:only => %w(blond red), :order => %w(blond red)).should == [["Blond hair", :blond], ["Red hair", :red]]
+    end
+
+    it "should override the labels for red and black" do
+      subject.user_hairs(:order => [:red, :blond, :brown, :black], :override => {:red => "Shiny Red Hair", :black => "Hell Black Hair"}).should == [["Shiny Red Hair", :red], ["Blond hair", :blond], ["Brown hair", :brown], ["Hell Black Hair", :black]]
+    end
+  end
+end

data/spec/locales/en.yml

@@ -0,0 +1,8 @@
+en:
+  activerecord:
+    enumerations:
+      user:
+        nationality:
+          gbr: "English"
+          esp: "Spanish"
+          pol: "Polish"

data/spec/matchers.rb

@@ -0,0 +1,11 @@
+RSpec::Matchers.define :include_module do |module_name|
+  match do |model|
+    model.class.include? module_name
+  end
+end
+
+RSpec::Matchers.define :have_defined_method do |method|
+  match do |mod|
+    mod.method_defined? method
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'active_record'
+require 'enumerated'
+require 'fixtures/models'
+require 'matchers'
+
+ActiveRecord::Base.establish_connection({'adapter' => 'sqlite3', 'database' => ':memory:'})
+
+connection = ActiveRecord::Base.connection
+
+connection.create_table(:users, :force => true) do |t|
+  t.string :gender
+  t.string :hair
+  t.string :nationality
+end
+
+connection.create_table(:dogs, :force => true) do |t|
+  t.string :name
+end

data/spec/user_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+describe User do
+
+  it { should include_module Enumerated }
+  it { should respond_to :gender }
+  it { should respond_to :gender= }
+  it { should respond_to :hair }
+  it { should respond_to :hair= }
+  it { should respond_to :nationality }
+  it { should respond_to :nationality= }
+  it { should be_valid }
+
+  its(:gender) { should == nil }
+  its(:gender_label) { should == nil }
+  its(:hair) { should == nil }
+  its(:hair_label) { should == nil }
+
+  context "class" do
+    subject { User.new.class }
+
+    it { should respond_to :genders }
+    it { should respond_to :hairs }
+    it { should respond_to :nationalities }
+
+    its(:genders) { should == [["Male", :male], ["Female", :female]] }
+    its(:hairs) { should == [["Black hair", :black], ["Brown hair", :brown], ["Red hair", :red], ["Blond hair", :blond]] }
+    its(:nationalities) { should == [["English", "gbr"], ["Spanish", "esp"], ["Polish", "pol"]] }
+
+    context "ordered" do
+      it "should return genders in female, male order" do
+        subject.genders(:order => [:female, :male]).should == [["Female", :female], ["Male", :male]]
+      end
+
+      it "should return hairs in red, blond, brown, black order" do
+        subject.hairs(:order => [:red, :blond, :brown, :black]).should == [["Red hair", :red], ["Blond hair", :blond], ["Brown hair", :brown], ["Black hair", :black]]
+      end
+
+      it "should return nationalities in pol, esp, gbr order" do
+        subject.nationalities(:order => [:pol, :esp, :gbr]).should == [["Polish", "pol"], ["Spanish", "esp"], ["English", "gbr"]]
+      end
+    end
+
+    context "except" do
+      it "should return genders except male" do
+        subject.genders(:except => [:male]).should == [["Female", :female]]
+      end
+
+      it "should return hairs except brown and black" do
+        subject.hairs(:order => [:red, :blond], :except => [:brown, :black]).should == [["Red hair", :red], ["Blond hair", :blond]]
+      end
+
+      it "should return nationalities except pol" do
+        subject.nationalities(:order => [:esp, :gbr], :except => [:pol]).should == [["Spanish", "esp"], ["English", "gbr"]]
+      end
+    end
+
+    context "only" do
+      it "should return only male gender" do
+        subject.genders(:only => [:male]).should == [["Male", :male]]
+      end
+
+      it "should return only brown and black hair" do
+        subject.hairs(:order => [:brown, :black], :only => [:brown, :black]).should == [["Brown hair", :brown], ["Black hair", :black]]
+      end
+
+      it "should return only pol nationality" do
+        subject.nationalities(:only => [:pol]).should == [["Polish", "pol"]]
+      end
+    end
+
+    context "override" do
+      it "should override the label for female" do
+        subject.genders(:override => {:female => "Madam"}).should == [["Male", :male], ["Madam", :female]]
+      end
+
+      it "should override the labels for red and black" do
+        subject.hairs(:order => [:red, :blond, :brown, :black], :override => { :red => "Shiny Red Hair", :black => "Hell Black Hair" }).should == [["Shiny Red Hair", :red], ["Blond hair", :blond], ["Brown hair", :brown], ["Hell Black Hair", :black]]
+      end
+
+      it "should override the label for pol" do
+        subject.nationalities(:except => [:gbr], :order => [:esp, :pol], :override => { :pol => "Polak" }).should == [["Spanish", "esp"], ["Polak", "pol"]]
+      end
+    end
+  end
+
+  context "when assigned a gender" do
+    before(:each) { subject.gender = :female }
+
+    it { should be_valid }
+    its(:gender) { should == :female }
+    its(:gender_label) { should == "Female" }
+    its(:female?) { should == true }
+    its(:male?) { should == false }
+  end
+
+  context "when assigned a gender using bang method" do
+    before(:each) { subject.male! }
+
+    it { should be_valid }
+    its(:gender) { should == :male }
+    its(:gender_label) { should == "Male" }
+    its(:female?) { should == false }
+    its(:male?) { should == true }
+  end
+
+  context "when assigned a gender as string" do
+    before(:each) { subject.gender = "female" }
+
+    it { should be_valid }
+    its(:gender) { should == "female" }
+    its(:gender_label) { should == "Female" }
+    its(:female?) { should == true }
+    its(:male?) { should == false }
+  end
+
+  context "when assigned an invalid gender" do
+    before(:each) { subject.gender = :unknown; subject.valid? }
+
+    it { should_not be_valid }
+
+    its(:errors) { should_not be_empty }
+    its(:errors) { should have(1).error_on(:gender) }
+  end
+
+  context "when assigned a blank gender" do
+    before(:each) { subject.gender = "" }
+
+    it { should be_valid }
+    its(:gender) { should == "" }
+    its(:gender_label) { should == nil }
+    its(:female?) { should == false }
+    its(:male?) { should == false }
+  end
+
+  context "when assigned a hair" do
+    before(:each) { subject.hair = :blond }
+
+    it { should be_valid }
+    its(:hair) { should == :blond }
+    its(:hair_label) { should == "Blond hair" }
+    its(:black?) { should == false }
+    its(:brown?) { should == false }
+    its(:red?) { should == false }
+    its(:blond?) { should == true }
+  end
+
+  context "when assigned a hair using bang method" do
+    before(:each) { subject.red! }
+
+    it { should be_valid }
+    its(:hair) { should == :red }
+    its(:hair_label) { should == "Red hair" }
+    its(:black?) { should == false }
+    its(:brown?) { should == false }
+    its(:red?) { should == true }
+    its(:blond?) { should == false }
+  end
+
+  context "when assigned a hair as string" do
+    before(:each) { subject.hair = "brown" }
+
+    it { should be_valid }
+    its(:hair) { should == "brown" }
+    its(:hair_label) { should == "Brown hair" }
+    its(:black?) { should == false }
+    its(:brown?) { should == true }
+    its(:red?) { should == false }
+    its(:blond?) { should == false }
+  end
+
+  context "when assigned a blank hair" do
+    before(:each) { subject.hair = "" }
+
+    it { should be_valid }
+    its(:hair) { should == "" }
+    its(:hair_label) { should == nil }
+    its(:black?) { should == false }
+    its(:brown?) { should == false }
+    its(:red?) { should == false }
+    its(:blond?) { should == false }
+  end
+
+  context "when assigned an invalid hair" do
+    # Validation for :hair is turned off
+    before(:each) { subject.hair = :curly; subject.valid? }
+
+    it { should be_valid }
+    its(:errors) { should be_empty }
+  end
+
+  context "when assigned a nationality" do
+    before(:each) { subject.nationality = :esp }
+
+    it { should be_valid }
+    its(:nationality) { should == :esp }
+    its(:nationality_label) { should == "Spanish" }
+    its(:gbr?) { should == false }
+    its(:esp?) { should == true }
+    its(:pol?) { should == false }
+  end
+
+  context "when assigned a nationality using bang method" do
+    before(:each) { subject.pol! }
+
+    it { should be_valid }
+    its(:nationality) { should == :pol }
+    its(:nationality_label) { should == "Polish" }
+    its(:gbr?) { should == false }
+    its(:esp?) { should == false }
+    its(:pol?) { should == true }
+  end
+
+  context "when assigned a nationality as string" do
+    before(:each) { subject.nationality = "gbr" }
+
+    it { should be_valid }
+    its(:nationality) { should == "gbr" }
+    its(:nationality_label) { should == "English" }
+    its(:gbr?) { should == true }
+    its(:esp?) { should == false }
+    its(:pol?) { should == false }
+  end
+
+  context "when assigned a blank nationality" do
+    before(:each) { subject.nationality = "" }
+
+    it { should be_valid }
+    its(:nationality) { should == "" }
+    its(:nationality_label) { should == nil }
+    its(:gbr?) { should == false }
+    its(:esp?) { should == false }
+    its(:pol?) { should == false }
+  end
+
+  context "when assigned an invalid hair" do
+    before(:each) { subject.nationality = :rus; subject.valid? }
+
+    it { should_not be_valid }
+
+    its(:errors) { should_not be_empty }
+    its(:errors) { should have(1).error_on(:nationality) }
+  end
+
+end

data/spec/users_helper_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe UsersHelper do
+  it { should have_defined_method :user_genders }
+  it { should_not have_defined_method :user_hairs }
+  it { should_not have_defined_method :user_nationalities }
+
+  context "should include method" do
+    subject { Class.new { include UsersHelper }.new }
+
+    its(:user_genders) { should == [["Male", :male], ["Female", :female]] }
+  end
+
+  context "parametrized" do
+    subject { Class.new { include UsersHelper }.new }
+
+    it "should return user genders in female, male order" do
+      subject.user_genders(:order => [:female, :male]).should == [["Female", :female], ["Male", :male]]
+    end
+
+    it "should return user genders except female" do
+      subject.user_genders(:except => [:female]).should == [["Male", :male]]
+    end
+
+    it "should return only male as user genders" do
+      subject.user_genders(:only => [:male]).should == [["Male", :male]]
+    end
+
+    it "should override the label for female" do
+      subject.user_genders(:override => {:female => "Madam"}).should == [["Male", :male], ["Madam", :female]]
+    end
+  end
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification 
+name: enumerated
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 1
+  version: 1.0.1
+platform: ruby
+authors: 
+- Michal Orman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-28 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Goal of the Enumerated gem is to provide support to use enumerations on selection/drop down lists.
+email: 
+- michal.orman@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- enumerator.gemspec
+- lib/enumerated.rb
+- lib/enumerated/definition.rb
+- lib/enumerated/version.rb
+- spec/dog_spec.rb
+- spec/fixtures/helpers.rb
+- spec/fixtures/models.rb
+- spec/hairs_helper_spec.rb
+- spec/locales/en.yml
+- spec/matchers.rb
+- spec/spec_helper.rb
+- spec/user_spec.rb
+- spec/users_helper_spec.rb
+has_rdoc: true
+homepage: https://github.com/michalorman/enumerated
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: enumerated
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Yet another enumeration gem for ActiveRecord
+test_files: []
+