galetahub-enum_field 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96da53c393009eaee6d98a66b4107c243577a44c
-  data.tar.gz: 7c17bffc0d29bfdb5b8399341031bb296f287835
+  metadata.gz: d8fe01fd9a421a42a8bc5a49fc1f1f57d78b3ef8
+  data.tar.gz: 3b86f719ab1b2dc329af61fca85ffff9e797bf42
 SHA512:
-  metadata.gz: 4ae37aca910cbef3b82a0a67ea4003368c5b832654fcd404b9e45d4e986bbe5f371c2b10f2381c9448d92c064e2111ca487b09cb2937c39d94da306b7ba8a764
-  data.tar.gz: fca89c19f39e43eadca5395b860d3d3fc9d6b8a669dd0ad37820d5511a25e1a6bce8f86f442aa95e716ac6c69edb641e5667b70129ef8bb5786dbafae71e1e70
+  metadata.gz: c51540d123b2444fbc79dcde8457590960911e5147d19aac45931eda9ce5aa842efe64bd95e5fa3e258e5699e51d9fe3b47c33348290be6dfd9040d003f634e8
+  data.tar.gz: 744b7af8a17cf2c2ee51f5a1d154a42ad03926a2a5e8f72943d63f5053110f658a7ce2bfe97c50f7ed2ad3040fd9e7cffc6df90b415ebd40f5d01e782beb7446

data/README.md

@@ -0,0 +1,138 @@
+# enum_field
+
+[![Build Status](https://semaphoreci.com/api/v1/igor-galeta/enum_field/branches/master/shields_badge.svg)](https://semaphoreci.com/igor-galeta/enum_field)
+[![Code Climate](https://codeclimate.com/github/galetahub/enum_field/badges/gpa.svg)](https://codeclimate.com/github/galetahub/enum_field)
+
+Enables Active Record attributes to point to enum like objects, by saving in your database
+only an integer ID.
+
+## INSTALL:
+
+    gem 'galetahub-enum_field', require: 'enum_field'
+
+## FEATURES:
+
+* Allows creation of Classes with enum like behaviour.
+* Allows any number of members and methods in the enum classes.
+* Allows an integer id to be used in your database columns to link to the enum members (user.role_id)
+* Enables higher abstraction interaction with +AR+ attributes:
+  * <code>user.role = Role.admin</code>
+  * <code>if user.role.can_edit?</code>
+* Saves in your +AR+ tables, only an integer id pointing to the enumeration member.
+
+## SYNOPSIS:
+
+When in an Active Record class, you have an attribute like role, state or country you have
+several options.
+
+* You can create a roles, states or countries table, and dump there all possible values.
+* You can use a string to identify, for instance, the role.
+* You can use an id to identify the role.
+
+If you are not comfortable with any of this options, maybe +enum_field+ is an answer for you.
+
+## BASIC USAGE:
+
+Define rules:
+
+``` ruby
+class Role
+  include EnumField::DefineEnum
+
+  define_enum do
+    member :admin
+    member :manager
+    member :employee
+  end
+end
+
+class User < ActiveRecord::Base
+  extend EnumField::EnumeratedAttribute
+
+  # in the database table there is a role_id integer column
+  enumerated_attribute :role
+end
+```
+
+Usage:
+
+``` ruby
+user.role = Role.manager
+user.role_id == Role.manager.id  # will be true
+
+Role.manager.name # :manager
+user.role.name # :manager
+
+User.first.role.id == User.first.role_id  # will be true
+
+Role[:manager] == Role.manager # will be true
+Role['manager'] == Role.manager # will be true
+
+instance = Role[:employee]
+instance.admin?    # false
+instance.employee? # true
+```
+
+Your enum classes can have all the methods you need:
+
+``` ruby
+class PhoneType
+  include EnumField::DefineEnum
+
+  def initialize(name)
+    @name = name
+  end
+
+  define_enum do
+    member :home,       object: new('home')
+    member :commercial, object: new('commercial')
+    member :mobile,     object: new('mobile')
+  end
+end
+
+user.phone.type.name
+```
+
+You have some +AR+ like methods in enum classes
+
+``` ruby
+PhoneType.all == [PhoneType.home, PhoneType.commercial, PhoneType.mobile]  # ordered all
+PhoneType.first == PhoneType.home
+PhoneType.last == PhoneType.mobile
+
+PhoneType.find_by_id(PhoneType.home.id) == PhoneType.home
+PhoneType.find_by_id(123456) == nil
+PhoneType.find(2) == PhoneType.commercial
+PhoneType.find(123456)  # will raise
+
+PhoneType.find([1, 2]) == [PhoneType.home, PhoneType.commercial]
+```
+
+### Start id from specific number
+
+``` ruby
+class CommentType
+  include EnumField::DefineEnum
+
+  define_enum id_start_from: 100 do
+    member :video
+    member :audio
+    member :text
+  end
+end
+
+CommentType.video.id # 101
+CommentType.audio.id # 102
+CommentType.text.id  # 103
+```
+
+## Tests
+
+    bundle install
+    bundle exec rspec ./spec/
+
+## LICENSE
+
+(The MIT License)
+
+Copyright (c) 2017 Fodojo LLC

data/lib/enum_field.rb

@@ -1,20 +1,24 @@
 # encoding: utf-8
+
+# Basic usage:
+#
+# class Role
+#   include EnumField::DefineEnum
+#
+#   define_enum do
+#     member :admin
+#     member :manager
+#     member :employee
+#   end
+# end
+#
 module EnumField
   autoload :DefineEnum, 'enum_field/define_enum'
   autoload :Builder, 'enum_field/builder'
   autoload :EnumeratedAttribute, 'enum_field/enumerated_attribute'
   autoload :Version, 'enum_field/version'
-  
-  class BadId < StandardError
-    attr_reader :repeated_id
-
-    def initialize(repeated_id)
-      @repeated_id = repeated_id
-    end
-  end
 
   class RepeatedId < StandardError; end
   class InvalidId < StandardError; end
-  class InvalidOptions < StandardError; end
   class ObjectNotFound < StandardError; end
 end

data/lib/enum_field/builder.rb

@@ -1,96 +1,91 @@
 # encoding: utf-8
+
 module EnumField
   class Builder
+    METHODS = %w[all names find_by_id find first last ids].freeze
 
-    METHODS = [:all, :names, :find_by_id, :find, :first, :last]
+    attr_reader :members
 
-    def initialize(target)
+    def initialize(target, options = {})
       @target = target
-      @next_id = 0
-      @id2obj = {}
-      @name2obj = {}
-      @sorted = []
+      @options = options
+      @members = {}
     end
 
     def member(name, options = {})
-      obj, candidate_id = process_options(options)
-      assign_id(obj, candidate_id)
-      assign_name(obj, name)
-      define_in_meta(name) { obj }
-      save(name, obj)
-      obj.freeze
+      unique_name = normalize_name(name)
+      @members[unique_name] = create_new_object(unique_name, options)
     end
 
     def all
-      @sorted.dup
+      @members.values
+    end
+
+    def [](value)
+      unique_name = normalize_name(value)
+      @members[unique_name]
     end
 
     def names
-      @name2obj.keys
+      @members.keys
+    end
+
+    def first
+      key = names.first
+      @members[key]
+    end
+
+    def last
+      key = names.last
+      @members[key]
+    end
+
+    def ids
+      all.map(&:id)
     end
 
     def find(id)
-      find_by_id(id) or raise EnumField::ObjectNotFound
+      find_by_id(id) || raise(EnumField::ObjectNotFound)
     end
 
     def find_by_id(id)
       case id
-      when Integer, String, Float, Fixnum then
-        @id2obj[id.to_i]
       when Array then
-        id.inject([]) do |items, value|
-          if value && value.respond_to?(:to_i)
-            items << @id2obj[value.to_i]
-          end
-
-          items
-        end
+        all.select { |object| id.include?(object.id) }
+      else
+        all.detect { |object| object.id == id }
       end
     end
 
-    def first; @sorted.first; end
-    def last; @sorted.last; end
-
     private
 
-    def define_in_meta(name, &block)
-      metaclass = class << @target; self; end
-      metaclass.send(:define_method, name, &block)
-    end
+    def create_new_object(name, options)
+      object = (options[:object] || @target.new)
 
-    def assign_id(obj, candidate_id)
-      id = new_id(candidate_id)
-      obj.instance_variable_set(:@id, id)
-    end
-
-    def assign_name(obj, name)
-      obj.instance_variable_set(:@name, name)
-    end
+      object.instance_variable_set(:@name, name)
+      object.instance_variable_set(:@id, find_next_object_id(options))
+      object.freeze
 
-    def new_id(candidate)
-      validate_candidate_id(candidate)
-      candidate || find_next_id
+      object
     end
 
-    def validate_candidate_id(id)
-      raise EnumField::InvalidId.new(id) unless id.nil? || id.is_a?(Integer) && id > 0
-      raise EnumField::RepeatedId.new(id) if @id2obj.has_key?(id)
+    def find_next_object_id(options)
+      new_id = (options[:id] || generate_next_object_id)
+      validate_candidate_id!(new_id)
+      new_id
     end
 
-    def find_next_id
-      @next_id += 1 while @id2obj.has_key?(@next_id) || @next_id <= 0
-      @next_id
+    def generate_next_object_id
+      @options.fetch(:id_start_from, 0) + @members.size + 1
     end
 
-    def process_options(options)
-      raise EnumField::InvalidOptions unless options.reject {|k,v| k == :object || k == :id}.empty?
-      [options[:object] || @target.new, options[:id]]
+    def validate_candidate_id!(id)
+      raise EnumField::InvalidId.new(message: id) if id.nil?
+      raise EnumField::RepeatedId.new(message: id) if ids.include?(id)
     end
 
-    def save(name, obj)
-      @id2obj[obj.id] = obj
-      @sorted << obj
-      @name2obj[name] = obj
+    def normalize_name(value)
+      value.to_s.to_sym
     end
   end
 end

data/lib/enum_field/define_enum.rb

@@ -1,26 +1,55 @@
 # encoding: utf-8
+
 module EnumField
+  # Add enum methods to class
+  # Usage:
+  # class Role
+  #   include EnumField::DefineEnum
+  #   ...
+  # end
+  #
   module DefineEnum
     def self.included(base)
       base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
     end
 
     module ClassMethods
-      def self.extended(base)
-        base.class_eval do
-          attr_reader :id, :name
+      def define_enum(options = {}, &block)
+        @enum_builder ||= EnumField::Builder.new(self, options)
+        @enum_builder.instance_exec(&block)
+
+        EnumField::Builder::METHODS.each do |method|
+          define_singleton_method method do |*args, &method_block|
+            @enum_builder.send(method, *args, &method_block)
+          end
         end
-      end
 
-      def define_enum(&block)
-        @enum_builder ||= EnumField::Builder.new(self)
-        yield @enum_builder
+        @enum_builder.members.keys.each do |method|
+          define_singleton_method method do
+            @enum_builder.members[method]
+          end
 
-        EnumField::Builder::METHODS.each do |method|
-          define_singleton_method method do |*args, &block|
-            @enum_builder.send(method, *args, &block)
+          define_method "#{method}?" do
+            @name == method
           end
         end
+
+        define_singleton_method '[]' do |value|
+          @enum_builder[value]
+        end
+
+        @enum_builder.members.freeze
+      end
+    end
+
+    module InstanceMethods
+      def id
+        @id
+      end
+
+      def name
+        @name
       end
     end
   end

data/lib/enum_field/enumerated_attribute.rb

@@ -1,4 +1,7 @@
 # encoding: utf-8
+
+require 'active_support/inflector'
+
 module EnumField
   # Easies the inclusion of enumerations as ActiveRecord columns.
   # If you have a User AR, with a role_id column, you could do:
@@ -19,7 +22,7 @@ module EnumField
   # class User
   #   extend EnumField::EnumeratedAttribute
   #
-  #   has_many_enumerated_attributes :roles, :through  => UserRole
+  #   enumerated_attribute :role
   # end
   #
   # class UserRole < ActiveRecord::Base
@@ -41,53 +44,18 @@ module EnumField
     #    * +class+: the class that will be instantiated when +name_attribute+ method is called. Defaults to
     #      +name_attribute+ in camelcase form.
     #
-    def enumerated_attribute(name_attribute, options  = {})
+    def enumerated_attribute(name_attribute, options = {})
       id_attribute = (options[:id_attribute] || "#{name_attribute}_id").to_sym
       klass = options[:class] || (options[:class_name] || name_attribute).to_s.camelcase.constantize
 
       define_method(name_attribute) do
-        (raw = read_attribute(id_attribute)) && klass.find_by_id(raw)
+        raw = send(id_attribute)
+        klass.find_by_id(raw)
       end
 
       define_method("#{name_attribute}=") do |value|
-        write_attribute(id_attribute, value ? value.id : nil)
-      end
-    end
-
-    # alias of enumerated_attribute
-    alias belongs_to_enumerated_attribute enumerated_attribute
-
-    # Defines a one-to-many association between an AR class and the enumerated
-    # * +association+: the name of the one-to-many association, for instance +roles+
-    # * +options+: Valid options are:
-    #    * +through+ : the name of the AR class needed to persist the one-to-many association.
-    #       Defaults to AR class in camelcase form concatenated with the enumerated class in camelcase form.
-    #    * +class+:    the enumerated class, it will be instantiated +n+ times when +association+ method is called.
-    #       Defaults to +association+ in singular camelcase form.
-    def has_many_enumerated_attributes(association, options = {})
-      enum_attr = association.to_s.singularize
-      klass     = options[:class]   || enum_attr.camelcase.constantize
-      through   = options[:through] || (self.name + klass.name)
-      self_attribute = self.name.demodulize.underscore
-      association_ids = association.to_s.singularize + '_ids'
-      has_many_aux = through.demodulize.underscore.pluralize
-
-      has_many has_many_aux, {:class_name => through, :dependent => :destroy}
-
-      define_method(association) do
-        self.send(has_many_aux).map(&enum_attr.to_sym)
-      end
-
-      define_method(association.to_s + '=') do |values|
-        self.send(has_many_aux + '=', values.map{|g| through.constantize.new(self_attribute => self, enum_attr => g)})
-      end
-
-      define_method(association_ids) do
-         self.send(association).map(&:id)
-      end
-
-      define_method(association_ids + '=') do |values|
-        self.send(has_many_aux + '=', values.map{|g| g.to_i unless g.blank?}.compact.map{|g_id| through.constantize.new(self_attribute => self, enum_attr + '_id' => g_id) })
+        raw = value ? value.id : nil
+        send("#{id_attribute}=", raw)
       end
     end
   end

data/lib/enum_field/version.rb

@@ -1,3 +1,3 @@
 module EnumField
-  VERSION = "0.4.0".freeze
+  VERSION = '0.5.0'.freeze
 end

data/spec/enum_field/define_enum_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe EnumField::DefineEnum do
+  # Sample ruby class
+  class Role
+    include EnumField::DefineEnum
+
+    define_enum do
+      member :admin
+      member :manager
+      member :employee
+    end
+  end
+
+  it 'must setup class methods for fast instance get' do
+    expect(Role.admin).not_to eq nil
+    expect(Role.admin.id).to eq 1
+    expect(Role.admin.name).to eq :admin
+
+    expect(Role[:admin]).to eq(Role.admin)
+    expect(Role['admin']).to eq(Role.admin)
+  end
+
+  context 'static' do
+    it 'must get all instances' do
+      expect(Role.all.size).to eq 3
+      expect(Role.all).to eq [Role.admin, Role.manager, Role.employee]
+    end
+
+    it 'must get all names' do
+      expect(Role.names.size).to eq 3
+      expect(Role.names).to eq [:admin, :manager, :employee]
+    end
+
+    it 'must find_by_id one instance' do
+      expect(Role.find_by_id(1)).to eq Role.admin
+      expect(Role.find_by_id(2)).to eq Role.manager
+      expect(Role.find_by_id(3)).to eq Role.employee
+    end
+
+    it 'must find_by_id array of instances' do
+      expect(Role.find_by_id([2, 3])).to eq [Role.manager, Role.employee]
+      expect(Role.find_by_id([nil, 1])).to eq [Role.admin]
+    end
+
+    it 'must not find instance via wrong id' do
+      expect(Role.find_by_id(4)).to eq nil
+      expect(Role.find_by_id('1')).to eq nil
+      expect(Role.find_by_id(nil)).to eq nil
+      expect(Role.find_by_id('wrong')).to eq nil
+      expect(Role.find_by_id(0)).to eq nil
+      expect(Role.find_by_id(-1)).to eq nil
+    end
+
+    it 'must find one instance' do
+      expect(Role.find(1)).to eq Role.admin
+      expect(Role.find(2)).to eq Role.manager
+      expect(Role.find(3)).to eq Role[:employee]
+    end
+
+    it 'must not find one instance with invalid id' do
+      expect { Role.find(100) }.to raise_error(EnumField::ObjectNotFound)
+      expect { Role.find(-1) }.to raise_error(EnumField::ObjectNotFound)
+      expect { Role.find('1') }.to raise_error(EnumField::ObjectNotFound)
+      expect { Role.find(nil) }.to raise_error(EnumField::ObjectNotFound)
+    end
+
+    it 'must get first instance' do
+      expect(Role.first).to eq(Role.admin)
+    end
+
+    it 'must get last instance' do
+      expect(Role.last).to eq(Role.employee)
+    end
+
+    it 'must get all ids' do
+      expect(Role.ids).to eq([1, 2, 3])
+    end
+  end
+
+  context 'wrong id' do
+    it 'must raise error on dublicated id' do
+      expect do
+        # Wrong class
+        class PostType
+          include EnumField::DefineEnum
+
+          define_enum do
+            member :default, id: 1
+            member :video, id: 1
+            member :audio, id: 2
+          end
+        end
+      end.to raise_error(EnumField::RepeatedId)
+    end
+  end
+
+  context 'check' do
+    let(:instance) { Role[:admin] }
+
+    it 'must check methods' do
+      expect(instance.admin?).to eq true
+      expect(instance.manager?).to eq false
+      expect(instance.employee?).to eq false
+    end
+  end
+
+  context 'id start number' do
+    let(:start_number) { 100 }
+    let(:comment_type) do
+      Class.new(Object) do
+        include EnumField::DefineEnum
+
+        define_enum id_start_from: 100 do
+          member :video
+          member :audio
+          member :text
+        end
+      end
+    end
+
+    it 'must set id + start_number' do
+      expect(comment_type.video.id).to eq start_number + 1
+      expect(comment_type.audio.id).to eq start_number + 2
+      expect(comment_type.text.id).to eq start_number + 3
+    end
+  end
+end

data/spec/enum_field/enumerated_attribute_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe EnumField::EnumeratedAttribute do
+  # Sample ruby class
+  class RoleType
+    include EnumField::DefineEnum
+
+    define_enum do
+      member :admin
+      member :manager
+      member :employee
+    end
+  end
+
+  # Sample ruby class
+  class User
+    extend EnumField::EnumeratedAttribute
+
+    attr_accessor :role_type_id
+
+    enumerated_attribute :role_type
+
+    def initialize(role_type_id)
+      @role_type_id = role_type_id
+    end
+  end
+
+  let(:admin_user) { User.new(RoleType.admin.id) }
+  let(:new_role) { RoleType.employee }
+
+  it 'must set role value' do
+    expect(admin_user.role_type).to eq RoleType.admin
+    expect(admin_user.role_type_id).to eq RoleType.admin.id
+    expect(admin_user.role_type.admin?).to eq true
+  end
+
+  it 'must set role_type_id' do
+    expect {
+      admin_user.role_type = new_role
+    }.to change { admin_user.role_type_id }.from(RoleType.admin.id).to(new_role.id)
+  end
+end

data/spec/enum_field_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe EnumField do
+  it 'has a version number' do
+    expect(EnumField::VERSION).not_to be nil
+  end
+
+  it 'must be a module' do
+    expect(EnumField.is_a?(Module)).to eq true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'enum_field'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: galetahub-enum_field
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Igor Galeta
@@ -9,24 +9,84 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-11 00:00:00.000000000 Z
-dependencies: []
+date: 2017-04-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: Enables Active Record attributes to point to enum like objects, by saving
   in your database only an integer ID
 email: galeta.igor@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
+- README.md
 files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/enum_field.rb
 - lib/enum_field/builder.rb
 - lib/enum_field/define_enum.rb
 - lib/enum_field/enumerated_attribute.rb
 - lib/enum_field/version.rb
-- lib/enum_field.rb
-- MIT-LICENSE
-- Rakefile
-- README.rdoc
+- spec/enum_field/define_enum_spec.rb
+- spec/enum_field/enumerated_attribute_spec.rb
+- spec/enum_field_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/galetahub/enum_field
 licenses: []
 metadata: {}
@@ -45,9 +105,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: enum_field
-rubygems_version: 2.1.11
+rubyforge_project: 
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Enumerated attributes for Active Record
-test_files: []
+summary: Enumerated attributes for any ruby class aka Active Record
+test_files:
+- spec/enum_field/define_enum_spec.rb
+- spec/enum_field/enumerated_attribute_spec.rb
+- spec/enum_field_spec.rb
+- spec/spec_helper.rb

data/README.rdoc

@@ -1,143 +0,0 @@
-= enum_field
-
-* http://github.com/paraseba/enum_field
-
-== DESCRIPTION:
-
-Enables Active Record attributes to point to enum like objects, by saving in your database
-only an integer ID.
-
-== INSTALL:
-
-  gem 'galetahub-enum_field', require: 'enum_field'
-
-
-== FEATURES:
-
-* Allows creation of Classes with enum like behaviour.
-* Allows any number of members and methods in the enum classes.
-* Allows an integer id to be used in your database columns to link to the enum members (user.role_id)
-* Enables higher abstraction interaction with +AR+ attributes:
-  * <code>user.role = Role.admin</code>
-  * <code>if user.role.can_edit?</code>
-* Saves in your +AR+ tables, only an integer id pointing to the enumeration member.
-
-== SYNOPSIS:
-
-When in an Active Record class, you have an attribute like role, state or country you have
-several options.
-
-* You can create a roles, states or countries table, and dump there all possible values.
-* You can use a string to identify, for instance, the role.
-* You can use an id to identify the role.
-
-If you are not comfortable with any of this options, maybe +enum_field+ is an answer for you.
-
-== BASIC USAGE:
-
-  class Role
-    include EnumField::DefineEnum
-
-    define_enum do |builder|
-      builder.member :admin
-      builder.member :manager
-      builder.member :employee
-    end
-  end
-
-  class User < ActiveRecord::Base
-    extend EnumField::EnumeratedAttribute
-
-    # in the database table there is a role_id integer column
-    enumerated_attribute :role
-  end
-
-
-  link_to_if(current_user.role == Role.admin, edit_foo_path(@foo))
-
-  user.role = Role.manager
-  user.role_id == Role.manager.id  #will be true
-
-  Role.manager.name # :manager
-  user.role.name # :manager
-
-  User.first.role.id == User.first.role_id  #will be true
-
-Your enum classes can have all the methods you need:
-
-  class PhoneType
-    include EnumField::DefineEnum
-
-    def initialize(name)
-      @name = name
-    end
-    attr_reader :name
-
-    define_enum do |b|
-      b.member :home,       :object => new('home')
-      b.member :commercial, :object => new('commercial')
-      b.member :mobile,     :object => new('mobile')
-    end
-  end
-
-  user.phone.type.name
-
-You have some +AR+ like methods in enum classes
-
-  PhoneType.all == [PhoneType.home, PhoneType.commercial, PhoneType.mobile]  # ordered all
-  PhoneType.first == PhoneType.home
-  PhoneType.last == PhoneType.mobile
-
-  PhoneType.find_by_id(PhoneType.home.id) == PhoneType.home
-  PhoneType.find_by_id(123456) == nil
-  PhoneType.find(2) == PhoneType.commercial
-  PhoneType.find(123456)  # will raise
-
-  PhoneType.find([1, 2]) == [PhoneType.home, PhoneType.commercial]
-
-The library also mimics has_many :through behavior, for cases such as:
-
-  class Role
-    include EnumField::DefineEnum
-
-    define_enum do |builder|
-      builder.member :admin
-      builder.member :manager
-      builder.member :employee
-    end
-  end
-
-  class User
-    extend EnumField::EnumeratedAttribute
-
-    has_many_enumerated_attributes :roles, :through  => UserRole
-  end
-
-  class UserRole < ActiveRecord::Base
-    extend EnumField::EnumeratedAttribute
-
-    belongs_to :user
-    enumerated_attribute :role
-  end
-
-  user = User.create
-  user.role = [Role.manager, Role.admin]
-  user.roles.include?(Role.admin)         #will be true
-  user.roles.include?(Role.manager)       #will be true
-  user.roles.include?(Role.employee)      #will be false
-  user.role_ids.include?(Role.manager.id) #will be true
-  user.role_ids = [Role.employee.id]
-  user.roles.include?(Role.employee)      #will be true
-  user.roles.include?(Role.admin)         #will be false
-
-
-
-== REQUIREMENTS:
-
-* activerecord
-
-== LICENSE:
-
-(The MIT License)
-
-Copyright (c) 2009 Sebastián Bernardo Galkin