mcommons-enum_for 0.0.5 → 0.0.6

data/README.rdoc

@@ -31,7 +31,7 @@ migration has created a column of type VARCHAR on the table "taco".
     enum_for :state, :has => [ :new, :composed, :served, :eaten ]
   end
 
-For all enum_for enabled models, valid states are able to be read for an attribute by calling the plural of
+For all enum_for-enabled models, valid states are able to be read for an attribute by calling the plural of
 the attribute name:
 
   >> Taco.states 
@@ -65,7 +65,7 @@ Afterwards, you may use the named scopes as follows.  Remember to add the prefix
 
 The prefix may be overridden or omitted by using the :prefix option.
 
-== Predicate methods
+=== Predicate methods
 
 enum_for also creates predicate methods on instances of your class so that you can ask if they have any
 of the given enumerable states.  For example, if a Taco class has an enumerable type :taste with values
@@ -94,9 +94,11 @@ also omit the addition of the prefix by passing :prefix => nil to enum_for. Exam
 This makes Taco respond to named scopes like Taco.wacky_composed instead of the default, which
 would have prefixed the named_scopes with the name of the attribute.
 
-= TODO
+== Notes
 
- * Add option for default value
+This plugin doesn't implement default values for a model.  If this behavior is desired, you may be interested
+in the default_value_for plugin (available http://github.com/FooBarWidget/default_value_for/tree/master), 
+which has been successfully tested with enum_for.
 
 == Authors
 

data/enum_for.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = %q{enum_for}
-  s.version = "0.0.5"
+  s.version = "0.0.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mal McKay and Justin Leitgeb"]

data/lib/enum_for.rb

@@ -6,58 +6,68 @@ module EnumFor
 
   module SingletonMethods
 
-    # Creates an enumerable attribute on an ActiveRecord model.  Usage is as follows:
+    # Creates an enumerable attribute on an ActiveRecord model.  Usage is as 
+    # follows:
+    #
     #   enum_for :state, :has => [ :new, :composed, :served, :eaten ]
+    #
     # Any additional options will be passed directly to the ActiveRecord method 
-    # :validates_inclusion_of, which is used to validate the assigned values to this
-    # attribute.  Requires a column of type VARCHAR with the name of the first argument
-    # to +enum_for+.
+    # :validates_inclusion_of, which is used to validate the assigned values to 
+    # this attribute.  Requires a column of type VARCHAR with the name of the 
+    # first argument to +enum_for+.
     def enum_for(*args)
-      options   = args.extract_options!
-      additives = options[:add].respond_to?(:include?) ? options[:add] : ( options[:add].nil? ? [ ] : [ options[:add] ] )
-      attribute = args.first
+      opts        = args.extract_options!
+      attribute   = args.first
       
-      plural_attribute = attribute.to_s.pluralize
-      
-      # Accept both symbol and string forms for setting.  They'll both be saved as strings in the DB anyway,
-      # so no need to accept only one form in the validation.
-      all_valid_values = options[:has].map{|v| v.to_s} | options[:has].map{|v| v.to_sym}
-      
-      validates_inclusion_of attribute, options.except(:has, :prefix, :add).merge(:in => all_valid_values )
-      
-      prefix = options.has_key?(:prefix) ? options[:prefix] : attribute.to_s
+      attribute_s = attribute.to_s
+
+      additives         = Array.wrap(opts[:add])
+      plural_attribute  = attribute_s.pluralize
       
-      prefixed_values = options[:has].inject({}) do |res, elem| 
-        res.merge( [prefix, elem].compact.join('_') => elem.to_sym )
-      end
+      prefix = opts.has_key?(:prefix) ? opts[:prefix] : attribute_s
+
+      # Valid values are most likely Symbols anyway, but coerce them to be safe.
+      valid_symbols = opts[:has].map{|v| v.to_sym }
 
-      prefixed_values.each do |pv, v|
-        const_set(pv.upcase, v) if additives.include?(:constants)
+      valid_symbols.each do |val_sym|
+        val_s = val_sym.to_s
+        
+        prefixed_val = [ prefix, val_s ].compact.join('_')
         
-        # Create named scope for this value
-        named_scope pv, :conditions => { attribute => v.to_s } if additives.include?(:named_scopes)
+        # Create +optional+ constants
+        const_set(prefixed_val.upcase, val_sym) if additives.include?(:constants)
+        
+        # Create +optional+ named scopes
+        named_scope prefixed_val, :conditions => { attribute => val_s } if additives.include?(:named_scopes)
 
-        # Create predicate methods for values
-        if additives.include?(:predicate_methods) && !self.instance_methods.include?(pv)
-          define_method("#{pv}?") do
-            read_attribute(attribute) == v.to_s
-          end
+        # Create +optional+ predicate methods, but don't overwrite existing methods
+        if additives.include?(:predicate_methods) && !self.instance_methods.include?(prefixed_val)
+          define_method(prefixed_val + '?') do    # def foo?
+            read_attribute(attribute) == val_s    #   read_attribute(:foo) == 'foo'  
+          end                                     # end
         end
-      end
-
-      # Attributes returned are cast as Symbols from their VARCHAR representation in the DB.
-      define_method(attribute.to_s) do
-        self[attribute].to_sym unless self[attribute].nil?
+        
       end
       
-      # Define a custom setter method which casts input to a String.  Since we present the configuration
-      # of enum_fu using Symbols, this makes sense to provide to the user.
-      define_method("#{attribute}=") do |other|
-        self[attribute] = other.to_s
-      end
+      # Accepts assignment both from String and Symbol form of valid values.
+      validates_inclusion_of attribute, opts.except(:has, :prefix, :add).
+        merge(:in => valid_symbols | valid_symbols.map{|s| s.to_s } )
+      
+      # Custom reader method presents attribute value in Symbol form.
+      define_method(attribute_s) do                           # def foo
+        self[attribute].to_sym unless self[attribute].nil?    #   self[:foo].to_sym unless self[:foo].nil?
+      end                                                     # end
+      
+      # Custom setter method casting all attribute input to String, allows 
+      # assignment from Symbol form.
+      define_method(attribute_s + '=') do |other|  # def foo=(other)
+        self[attribute] = other.to_s               #    self[foo] = other 
+      end                                          # end
       
+      # Make collection of all valid attribute Symbols available to user
+      # from plural name of attribute as class method.
       cattr_reader plural_attribute.to_sym
-      class_variable_set(:"@@#{plural_attribute}", options[:has])    
+      class_variable_set(:"@@#{plural_attribute}", opts[:has])    
     end
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mcommons-enum_for
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Mal McKay and Justin Leitgeb