simple_enum 1.4.1 → 1.5.0

data/lib/simple_enum.rb

@@ -8,11 +8,11 @@
 #
 # See the +as_enum+ documentation for more details.
 
-# because we depend on AR and i18n
+# because we depend on i18n and activesupport
 require 'i18n'
+require 'active_support'
 
 require 'simple_enum/enum_hash'
-require 'simple_enum/object_support'
 require 'simple_enum/validation'
 
 require 'active_support/deprecation'
@@ -174,7 +174,7 @@ module SimpleEnum
 
       # generate getter
       define_method("#{enum_cd}") do
-        id = read_attribute options[:column]
+        id = respond_to?(:read_attribute) ? read_attribute(options[:column]) : send(options[:column])
         values_inverted[id]
       end
 
@@ -182,7 +182,15 @@ module SimpleEnum
       define_method("#{enum_cd}=") do |new_value|
         v = new_value.blank? ? nil : values[new_value.to_sym]
         raise(ArgumentError, "Invalid enumeration value: #{new_value}") if (options[:whiny] and v.nil? and !new_value.blank?)
-        write_attribute options[:column], v
+        respond_to?(:write_attribute) ? write_attribute(options[:column], v) : send("#{options[:column]}=", v)
+      end
+
+      # generate checker
+      define_method("#{enum_cd}?") do |*args|
+        current = send(enum_cd)
+        return current == EnumHash.symbolize(args.first) if args.length > 0
+
+        !!current
       end
 
       # support dirty attributes by delegating to column, currently opt-in
@@ -200,6 +208,10 @@ module SimpleEnum
       attr_name = enum_cd.to_s.pluralize
       enum_attr = :"#{attr_name.downcase}_enum_hash"
 
+      define_method("human_#{enum_cd}") do
+        self.class.human_enum_name(attr_name, self.send(enum_cd))
+      end
+
       class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         class_attribute #{enum_attr.inspect}, :instance_write => false, :instance_reader => false
 
@@ -226,13 +238,14 @@ module SimpleEnum
         prefix = options[:prefix] && "#{options[:prefix] == true ? enum_cd : options[:prefix]}_"
 
         values.each do |k,code|
-          sym = k.to_enum_sym
+          sym = EnumHash.symbolize(k)
 
           define_method("#{prefix}#{sym}?") do
-            code == read_attribute(options[:column])
+            current = respond_to?(:read_attribute) ? read_attribute(options[:column]) : send(options[:column])
+            code == current
           end
           define_method("#{prefix}#{sym}!") do
-            write_attribute options[:column], code
+            respond_to?(:write_attribute) ? write_attribute(options[:column], code) : send("#{options[:column]}=", code)
             sym
           end
 
@@ -247,19 +260,25 @@ module SimpleEnum
     include Validation
 
     def human_enum_name(enum, key, options = {})
-      klasses = self.respond_to?(:descendants) ? descendants : ancestors
-      defaults = ([self] + klasses).map { |klass| :"#{klass.name.underscore}.#{enum}.#{key}" }
-      defaults << :"#{enum}.#{key}"
+      defaults = lookup_ancestors.map do |klass|
+        :"#{self.i18n_scope}.enums.#{klass.model_name.i18n_key}.#{enum}.#{key}"
+      end
+
+      defaults << :"enums.#{self.model_name.i18n_key}.#{enum}.#{key}"
+      defaults << :"enums.#{enum}.#{key}"
       defaults << options.delete(:default) if options[:default]
-      defaults << "#{key}".humanize
-      options[:count] ||= 1
-      I18n.translate(defaults.shift, options.merge(:default => defaults.flatten, :scope => [:activerecord, :enums]))
+      defaults << key.to_s.humanize
+
+      options.reverse_merge! :count => 1, :default => defaults
+      I18n.translate(defaults.shift, options)
     end
   end
 end
 
-# Tie stuff together and load translations if ActiveRecord is defined
-Object.send(:include, SimpleEnum::ObjectSupport)
+# include in AR
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Base.send(:include, SimpleEnum)
+end
 
-ActiveRecord::Base.send(:include, SimpleEnum) if defined?(ActiveRecord)
+# setup i18n load path...
 I18n.load_path << File.join(File.dirname(__FILE__), '..', 'locales', 'en.yml')

data/lib/simple_enum/enum_hash.rb

@@ -1,46 +1,56 @@
 module SimpleEnum
-  
+
   # Internal hash class, used to handle the enumerations et al.
   # Works like to original +Hash+ class, but with some added value,
-  # like access to 
+  # like access to
+  #
   #
-  # 
   class EnumHash < ::ActiveSupport::OrderedHash
+
+    # Converts an entity to a symbol, uses to_enum_sym, if possible.
+    def self.symbolize(sym)
+      return sym.to_enum_sym if sym.respond_to?(:to_enum_sym)
+      return sym.to_sym if sym.respond_to?(:to_sym)
+      return sym.name.to_s.parameterize('_').to_sym if sym.respond_to?(:name)
+      sym.to_param.to_sym unless sym.blank?
+    end
+
     def initialize(args = [])
       super()
-      
+
       @reverse_sym_lookup = {}
       @sym_value_lookup = {}
 
       if args.is_a?(Hash)
         args.each { |k,v| set_value_for_reverse_lookup(k, v) }
       else
-        ary = args.send(args.respond_to?(:enum_with_index) ? :enum_with_index : :each_with_index).to_a unless args.first.is_a?(ActiveRecord::Base) or args.first.is_a?(Array)
-        ary = args.map { |e| [e, e.id] } if args.first.is_a?(ActiveRecord::Base)
+        ary = args.send(args.respond_to?(:enum_with_index) ? :enum_with_index : :each_with_index).to_a unless args.first.respond_to?(:map)
+        ary = args.map { |e| [e, e.id] } if args.first.respond_to?(:map) && !args.first.is_a?(Array)
         ary ||= args
         ary.each { |e| set_value_for_reverse_lookup(e[0], e[1]) }
       end
     end
-        
+
     def default(k = nil)
-      @sym_value_lookup[k.to_enum_sym] if k
+      @sym_value_lookup[EnumHash.symbolize(k)] if k
     end
-        
+
     def method_missing(symbol, *args)
-      if @sym_value_lookup.has_key?(symbol.to_enum_sym)
-        return @reverse_sym_lookup[symbol.to_enum_sym] if args.first
+      sym = EnumHash.symbolize(symbol)
+      if @sym_value_lookup.has_key?(sym)
+        return @reverse_sym_lookup[sym] if args.first
         self[symbol]
       else
         super
       end
     end
-    
+
     private
       def set_value_for_reverse_lookup(key, value)
-        sym = key.to_enum_sym
+        sym = EnumHash.symbolize(key)
         self[key] = value
         @reverse_sym_lookup[sym] = key
         @sym_value_lookup[sym] = value
-      end    
+      end
   end
 end

data/lib/simple_enum/mongoid.rb

@@ -0,0 +1,52 @@
+require 'simple_enum'
+
+module SimpleEnum
+
+  # Enables support for mongoid, also automatically creates the
+  # requested field.
+  #
+  #   class Person
+  #     include Mongoid::Document
+  #     include SimpleEnum::Mongoid
+  #
+  #     field :name
+  #     as_enum :gender, [:female, :male]
+  #   end
+  #
+  # When no field is requested:
+  #
+  #   field :gender_cd, :type => Integer
+  #   as_enum :gender, [:female, :male], :field => false
+  #
+  # or custom field options (like e.g. type want to be passed):
+  #
+  #   as_enum :gender, [:female, :male], :field => { :type => Integer }
+  #
+  module Mongoid
+    extend ActiveSupport::Concern
+
+    included do
+      # create class level methods
+      class_attribute :enum_definitions, :instance_write => false, :instance_reader => false
+      enum_definitions = {}
+    end
+
+    module ClassMethods
+      include SimpleEnum::ClassMethods
+
+      # Wrap method chain to create mongoid field and additional
+      # column options
+      def as_enum_with_mongoid(enum_cd, values, options = {})
+        options = SimpleEnum.default_options.merge({ :column => "#{enum_cd}_cd" }).merge(options)
+
+        # forward custom field options
+        field_options = options.delete(:field)
+        field(options[:column], field_options.is_a?(Hash) ? field_options : {}) unless field_options === false
+
+        # call original as_enum method
+        as_enum_without_mongoid(enum_cd, values, options)
+      end
+      alias_method_chain :as_enum, :mongoid
+    end
+  end
+end

data/lib/simple_enum/validation.rb

@@ -29,7 +29,7 @@ module SimpleEnum
         enum_def = enum_definitions[attr_name]
         unless send(enum_def[:name].to_s.pluralize).values.include?(value)
           params = { :value => value}
-          params[:default] = configuration[:message] if configuration[:message].present?
+          params[:message] = configuration[:message] if configuration[:message].present?
           record.errors.add(enum_def[:name], :invalid_enum, params)
         end
       end

data/lib/simple_enum/version.rb

@@ -1,5 +1,5 @@
 module SimpleEnum
 
   # +SimpleEnum+ version string.
-  VERSION = "1.4.1"
+  VERSION = "1.5.0"
 end

data/locales/en.yml

@@ -4,3 +4,7 @@ en:
     errors:
       messages:
         invalid_enum: invalid option supplied.
+  mongoid:   
+    errors:
+      messages:
+        invalid_enum: invalid option supplied.

data/simple_enum.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   s.name        = "simple_enum"
   s.version     = SimpleEnum::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.summary     = "Simple enum-like field support for active records."
-  s.description = ""
+  s.summary     = "Simple enum-like field support for models."
+  s.description = "Provides enum-like fields for ActiveRecord, ActiveModel and Mongoid models."
 
   s.required_ruby_version     = ">= 1.8.7"
   s.required_rubygems_version = ">= 1.3.6"
@@ -22,10 +22,12 @@ Gem::Specification.new do |s|
 
   s.license          = 'MIT'
 
-  s.add_dependency "activesupport", "~> 3.0"
-
-  s.add_development_dependency 'rake', '>= 0.8.7'
-  s.add_development_dependency 'activerecord', '~> 3.0'
+  s.add_dependency "activesupport", '>= 3.0.0'
+  
+  s.add_development_dependency 'rake', '>= 0.9.2'
+  s.add_development_dependency 'appraisal', '>= 0.4'
+  s.add_development_dependency 'minitest', '>= 2.3.0'
+  s.add_development_dependency 'activerecord', '>= 3.0.0'
   s.add_development_dependency 'mongoid', '~> 2.0'
 
   unless RUBY_PLATFORM =~ /java/

data/test/array_conversions_test.rb

@@ -1,23 +1,21 @@
 require 'test_helper'
 
-class ArrayConversionsTest < ActiveSupport::TestCase  
+class ArrayConversionsTest < MiniTest::Unit::TestCase
   def setup
     reload_db :genders => true
   end
   
-  test "that conversion of Gender.find(:all).map {...} to enumeration values as symbols works the same as [:male,:female]" do
-    class DummyArrayTest1 < ActiveRecord::Base
-      set_table_name 'dummies'
-      as_enum :gender, Gender.find(:all).map { |g| [g.name.to_sym, g.id] }
-    end
-    with_enum = DummyArrayTest1
+  def test_conversion_to_enumartions
+    with_enum = named_dummy('DummyArrayTest1') do
+       as_enum :gender, Gender.all.map { |g| [g.name.to_sym, g.id] }       
+    end   
     
-    assert_equal 0, with_enum.male
-    assert_equal 1, with_enum.female
-    assert_equal 1, with_enum.genders(:female)
+    assert_equal @male.id, with_enum.male
+    assert_equal @female.id, with_enum.female
+    assert_equal @female.id, with_enum.genders(:female)
     
     jane = with_enum.new :gender => :female
     assert_equal :female, jane.gender
-    assert_equal 1, jane.gender_cd    
+    assert_equal @female.id, jane.gender_cd    
   end
 end

data/test/class_methods_test.rb

@@ -1,38 +1,40 @@
 require 'test_helper'
 
-class ClassMethodsTest < ActiveSupport::TestCase
+class ClassMethodsTest < MiniTest::Unit::TestCase
   def setup
     reload_db
   end
 
-  test "that Klass.genders[:sym] == Klass.genders(:sym)" do
+  def test_that_klass_genders_array_accessor_equal_to_attr_accessor
     assert_equal 0, Dummy.genders(:male)
     assert_equal Dummy.genders(:male), Dummy.genders[:male]
     assert_nil Dummy.genders(:inexistent)
     assert_nil Dummy.genders[:inexistent]
-    assert_not_nil Dummy.genders[:female]
+    refute_nil Dummy.genders[:female]
   end
 
-  test "inheritance of `genders` to subclasses (#issue/3)" do
+  def test_inheritance_of_genders_to_subclasses
+    # issue#3
     assert_equal({ :female => 1, :male => 0}, SpecificDummy.genders)
   end
 
-  test "genders reader created" do
+  def test_genders_reader_created
     assert_equal [0, 1], Dummy.genders.values.sort
     assert_equal %w{female male}, Dummy.genders.keys.map(&:to_s).sort
   end
 
-  test "that Klass.genders(:sym_a, :sym_b) returns an array of values, useful for IN clauses" do
+  def test_that_klass_genders_return_array_of_values
+    # usefuled for IN clauses
     assert_equal [0, 1], Dummy.genders(:male, :female)
     assert_equal [1, 0], Dummy.genders(:female, :male)
   end
 
-  test "inverted Hash returns synonym by code" do
+  def test_inverted_hash_returns_synonym_by_code
     assert_equal :male, Dummy.genders.invert[0]
     assert_equal :female, Dummy.genders.invert[1]
   end
 
-  test "generation of value shortcuts on class" do
+  def test_generation_of_value_shortcuts_on_class
     g = Dummy.new
 
     assert_equal 0, Dummy.male
@@ -44,24 +46,20 @@ class ClassMethodsTest < ActiveSupport::TestCase
     assert_respond_to Dummy, :foobar
   end
 
-  test "that no Klass.shortcut are created if :slim => true" do
-    class Dummy1 < ActiveRecord::Base
-      set_table_name 'dummies'
+  def test_that_no_klass_shortcuts_are_created_if_slim_true
+    with_slim = named_dummy('Dummy1') do
       as_enum :gender, [:male, :female], :slim => true
     end
-    with_slim = Dummy1
 
     assert !with_slim.respond_to?(:male)
     assert !with_slim.respond_to?(:female)
     assert_respond_to with_slim, :genders
   end
 
-  test "that no Klass.shortcut's are created if :slim => :class, though instance shortcuts are" do
-    class Dummy2 < ActiveRecord::Base
-      set_table_name 'dummies'
+  def test_that_no_klass_shortcuts_are_created_if_slim_class_though_instance_shortcuts_are
+    with_slim_class = named_dummy('Dummy2') do
       as_enum :gender, [:male, :female], :slim => :class
     end
-    with_slim_class = Dummy2
 
     jane = with_slim_class.new
 
@@ -74,12 +72,10 @@ class ClassMethodsTest < ActiveSupport::TestCase
     assert_same 1, with_slim_class.genders[:female]
   end
 
-  test "that Klass.shortcut respect :prefix => true and are prefixed by \#{enum_cd}" do
-    class Dummy3 < ActiveRecord::Base
-      set_table_name 'dummies'
+  def test_that_klass_shortcuts_respect_prefix_true_and_are_prefixed_by_enum_cd
+    with_prefix = named_dummy('Dummy3') do
       as_enum :gender, [:male, :female], :prefix => true
     end
-    with_prefix = Dummy3
 
     assert !with_prefix.respond_to?(:male)
     assert !with_prefix.respond_to?(:female)
@@ -89,12 +85,10 @@ class ClassMethodsTest < ActiveSupport::TestCase
     assert_respond_to with_prefix, :genders
   end
 
-  test "to ensure that Klass.shortcut also work with custom prefixes" do
-    class Dummy4 < ActiveRecord::Base
-      set_table_name 'dummies'
+  def test_to_ensure_that_klass_shortcut_also_work_with_custom_prefixes
+    with_custom_prefix = named_dummy('Dummy4') do
       as_enum :gender, [:male, :female], :prefix => :g
     end
-    with_custom_prefix = Dummy4
 
     assert !with_custom_prefix.respond_to?(:male)
     assert !with_custom_prefix.respond_to?(:female)
@@ -105,22 +99,14 @@ class ClassMethodsTest < ActiveSupport::TestCase
     assert_respond_to with_custom_prefix, :genders
   end
 
-  test "that the human_enum_name method returns translated/humanized values" do
+  def test_that_the_human_enum_name_method_returns_translated_humanized_values
     assert_equal :male.to_s.humanize, Dummy.human_enum_name(:genders, :male)
     assert_equal "Girl", Dummy.human_enum_name(:genders, :female)
     assert_equal "Foo", Dummy.human_enum_name(:didums, :foo)
     assert_equal "Foos", Dummy.human_enum_name(:didums, :foo, :count => 5)
   end
 
-  test "enum_for_select class method" do
-    for_select = Dummy.genders_for_select
-    genders = Dummy.genders
-    assert_equal genders.first.first, for_select.first.second
-    assert_equal ["Male", :male], for_select.first
-    assert_equal ["Girl", :female], for_select.last
-  end
-
-  test "enum_for_select(:value) class method" do
+  def test_enum_for_select_value_class_method
     for_select = Dummy.genders_for_select(:value)
     assert_equal ["Male", 0], for_select.first
     assert_equal ["Girl", 1], for_select.last