lib/simple_enum.rb in simple_enum-1.5.1 vs lib/simple_enum.rb in simple_enum-1.6.1

@@ -43,12 +43,11 @@
         :upcase => false
       }
     end
 
     def included(base) #:nodoc:
-      base.send :class_attribute, :enum_definitions, :instance_write => false, :instance_reader => false
-      base.enum_definitions = {}
+      base.send :class_attribute, :simple_enum_definitions, :instance_writer => false, :instance_reader => false
       base.send :extend, ClassMethods
     end
   end
 
   module ClassMethods
@@ -164,27 +163,27 @@
       # convert array to hash...
       values = SimpleEnum::EnumHash.new(values)
       values_inverted = values.invert
 
       # store info away
-      self.enum_definitions = {} if self.enum_definitions.nil?
       self.enum_definitions[enum_cd] = self.enum_definitions[options[:column]] = { :name => enum_cd, :column => options[:column], :options => options }
 
-      # display deprecation warning if enum_cd == column
-      ActiveSupport::Deprecation.warn "[simple_enum] use different names for #{enum_cd}'s name and column name (support for this will be dropped in 1.5)" if enum_cd.to_s == options[:column].to_s
+      # raise error if enum_cd == column
+      raise ArgumentError, "[simple_enum] use different names for #{enum_cd}'s name and column name." if enum_cd.to_s == options[:column].to_s
 
       # generate getter
       define_method("#{enum_cd}") do
         id = respond_to?(:read_attribute) ? read_attribute(options[:column]) : send(options[:column])
         values_inverted[id]
       end
 
       # generate setter
       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?)
-        respond_to?(:write_attribute) ? write_attribute(options[:column], v) : send("#{options[:column]}=", v)
+        real = new_value.blank? ? nil : values[EnumHash.symbolize(new_value)]
+        real = new_value if real.nil? && values_inverted[new_value].present?
+        raise(ArgumentError, "Invalid enumeration value: #{new_value}") if (options[:whiny] and real.nil? and !new_value.blank?)
+        respond_to?(:write_attribute) ? write_attribute(options[:column], real) : send("#{options[:column]}=", real)
       end
 
       # generate checker
       define_method("#{enum_cd}?") do |*args|
         current = send(enum_cd)
@@ -211,11 +210,11 @@
       define_method("human_#{enum_cd}") do
         self.class.human_enum_name(attr_name, self.send(enum_cd)) unless self.send(enum_cd).nil?
       end
 
       class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        class_attribute #{enum_attr.inspect}, :instance_write => false, :instance_reader => false
+        class_attribute #{enum_attr.inspect}, :instance_writer => false, :instance_reader => false
 
         def self.#{attr_name}(*args)
           return #{enum_attr} if args.first.nil?
           return #{enum_attr}[args.first] if args.size == 1
           args.inject([]) { |ary, sym| ary << #{enum_attr}[sym]; ary }
@@ -269,9 +268,13 @@
       defaults << options.delete(:default) if options[:default]
       defaults << key.to_s.humanize
 
       options.reverse_merge! :count => 1, :default => defaults
       I18n.translate(defaults.shift, options)
+    end
+
+    def enum_definitions
+      self.simple_enum_definitions ||= {}
     end
   end
 end
 
 # include in AR