1 files changed, 88 insertions, 0 deletions
diff --git a/activerecord/lib/active_record/enum.rb b/activerecord/lib/active_record/enum.rb
new file mode 100644
index 0000000000..5fcc0382d8
--- /dev/null
+++ b/activerecord/lib/active_record/enum.rb
@@ -0,0 +1,88 @@
+module ActiveRecord
+  # Declare an enum attribute where the values map to integers in the database, but can be queried by name. Example:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum status: [ :active, :archived ]
+  #   end
+  #
+  #   # conversation.update! status: 0
+  #   conversation.active!
+  #   conversation.active? # => true
+  #   conversation.status  # => "active"
+  #
+  #   # conversation.update! status: 1
+  #   conversation.archived!
+  #   conversation.archived? # => true
+  #   conversation.status    # => "archived"
+  #
+  #   # conversation.update! status: 1
+  #   conversation.status = "archived"
+  #
+  # You can set the default value from the database declaration, like:
+  #
+  #   create_table :conversations do |t|
+  #     t.column :status, :integer, default: 0
+  #   end
+  #
+  # Good practice is to let the first declared status be the default.
+  #
+  # Finally, it's also possible to explicitly map the relation between attribute and database integer:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum status: { active: 0, archived: 1 }
+  #   end
+  #
+  # In rare circumstances you might need to access the mapping directly.
+  # The mappings are exposed through a constant with the attributes name:
+  #
+  #   Conversation::STATUS # => { "active" => 0, "archived" => 1 }
+  #
+  # Use that constant when you need to know the ordinal value of an enum:
+  #
+  #   Conversation.where("status <> ?", Conversation::STATUS[:archived])
+  module Enum
+    def enum(definitions)
+      klass = self
+      definitions.each do |name, values|
+        # DIRECTION = { }
+        enum_values = _enum_methods_module.const_set name.to_s.upcase, ActiveSupport::HashWithIndifferentAccess.new
+        name        = name.to_sym
+
+        _enum_methods_module.module_eval do
+          # def direction=(value) self[:direction] = DIRECTION[value] end
+          define_method("#{name}=") { |value|
+            unless enum_values.has_key?(value)
+              raise ArgumentError, "'#{value}' is not a valid #{name}"
+            end
+            self[name] = enum_values[value]
+          }
+
+          # def direction() DIRECTION.key self[:direction] end
+          define_method(name) { enum_values.key self[name] }
+
+          pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
+          pairs.each do |value, i|
+            enum_values[value] = i
+
+            # scope :incoming, -> { where direction: 0 }
+            klass.scope value, -> { klass.where name => i }
+
+            # def incoming?() direction == 0 end
+            define_method("#{value}?") { self[name] == i }
+
+            # def incoming! update! direction: :incoming end
+            define_method("#{value}!") { update! name => value }
+          end
+        end
+      end
+    end
+
+    def _enum_methods_module
+      @_enum_methods_module ||= begin
+        mod = Module.new
+        include mod
+        mod
+      end
+    end
+  end
+end