enumerated_attribute 0.2.7

data/lib/enumerated_attribute/integrations.rb

@@ -0,0 +1,33 @@
+require 'enumerated_attribute/integrations/active_record'
+require 'enumerated_attribute/integrations/object'
+require 'enumerated_attribute/integrations/datamapper'
+require 'enumerated_attribute/integrations/default'
+
+module EnumeratedAttribute
+	module Integrations
+
+		@@integration_map = {}
+		
+		def self.add_integration_map(base_klass_name, module_object, aliasing_array=[])
+			@@integration_map[base_klass_name] = {:module=>module_object, :aliasing=>aliasing_array}
+		end
+		class << self
+			alias_method(:add, :add_integration_map)
+		end
+		
+		#included mappings
+		add('Object', EnumeratedAttribute::Integrations::Object)
+		add('ActiveRecord::Base', EnumeratedAttribute::Integrations::ActiveRecord)
+		
+		def self.find_integration_map(klass)
+			path = "#{klass}"
+			begin
+				return @@integration_map[klass.to_s] if @@integration_map.key?(klass.to_s)
+				klass = klass.superclass
+				path << " < #{klass}"
+			end while klass
+			raise EnumeratedAttribute::IntegrationError, "Unable to find integration for class hierarchy '#{path}'", caller
+		end
+	
+	end
+end

data/lib/enumerated_attribute/integrations/active_record.rb

@@ -0,0 +1,109 @@
+module EnumeratedAttribute
+	module Integrations
+
+		module ActiveRecord
+			def self.included(klass)
+				klass.extend(ClassMethods)
+			end
+			
+			def write_enumerated_attribute(name, val)
+				name = name.to_s
+				return write_attribute(name, val) unless self.class.has_enumerated_attribute?(name)
+				val = nil if val == ''
+				val_str = val.to_s if val
+				val_sym = val.to_sym if val
+				unless self.class.enumerated_attribute_allows_value?(name, val_sym)
+					raise(InvalidEnumeration, "nil is not allowed on '#{name}' attribute, set :nil=>true option", caller) unless val
+					raise(InvalidEnumeration, ":#{val_str} is not a defined enumeration value for the '#{name}' attribute", caller)
+				end
+				return instance_variable_set('@'+name, val_sym) unless self.has_attribute?(name)
+				write_attribute(name, val_str)
+				val_sym
+			end
+			
+			def read_enumerated_attribute(name)
+				name = name.to_s
+				#if not enumerated - let active record handle it
+				return read_attribute(name) unless self.class.has_enumerated_attribute?(name)
+				#if enumerated, is it an active record attribute, if not, the value is stored in an instance variable
+				name_sym = name.to_sym
+				return instance_variable_get('@'+name) unless self.has_attribute?(name)
+				#this is an enumerated active record attribute
+				val = read_attribute(name)
+				val = val.to_sym if !!val
+				val
+			end
+			
+			def attributes=(attrs, guard_protected_attributes=true)
+				return if attrs.nil?
+				#check the attributes then turn them over 
+				attrs.each do |k, v|
+					if self.class.has_enumerated_attribute?(k)
+						unless self.class.enumerated_attribute_allows_value?(k, v)
+							raise InvalidEnumeration, ":#{v.to_s} is not a defined enumeration value for the '#{k.to_s}' attribute", caller
+						end
+						attrs[k] = v.to_s
+					end
+				end
+				
+				super
+			end
+			
+			def attributes
+				atts = super
+				atts.each do |k,v|
+					if self.class.has_enumerated_attribute?(k)
+						atts[k] = v.to_sym if v
+					end
+				end
+				atts
+			end
+			
+      def [](attr_name); read_enumerated_attribute(attr_name); end
+      def []=(attr_name, value); write_enumerated_attribute(attr_name, value); end
+			
+			private
+						
+			def attribute=(attr_name, value); write_enumerated_attribute(attr_name, value); end
+									
+			module ClassMethods
+				private
+				
+				def construct_attributes_from_arguments(attribute_names, arguments)
+					attributes = super
+					attributes.each { |k,v| attributes[k] = v.to_s if has_enumerated_attribute?(k) }
+					attributes
+				end
+				
+				def instantiate(record)
+					object = super(record)
+					self.enumerated_attributes.each do |k,v|
+						unless object.has_attribute?(k) #only initialize the non-column enumerated attributes
+							object.write_enumerated_attribute(k, v.init_value)
+						end
+					end
+					object
+				end
+				
+				def define_enumerated_attribute_new_method
+					class_eval do
+						class << self
+							unless method_defined?(:new_without_enumerated_attribute)						
+								alias_method :new_without_enumerated_attribute, :new
+								def new(*args, &block)
+									result = new_without_enumerated_attribute(*args, &block)
+									params = (!args.empty? && args.first.instance_of?(Hash)) ? args.first : {}
+									params.each { |k, v| result.write_enumerated_attribute(k, v) }
+									result.initialize_enumerated_attributes(true)
+									yield result if block_given?
+									result
+								end
+							end
+						end
+          end
+				end
+
+			end
+		end	
+	end
+end

data/lib/enumerated_attribute/integrations/datamapper.rb

@@ -0,0 +1,6 @@
+module EnumerateAttribute
+	module Integrations
+		module Datamapper
+		end
+	end
+end

data/lib/enumerated_attribute/integrations/default.rb

@@ -0,0 +1,25 @@
+module EnumeratedAttribute
+	module Integrations
+
+		module Default
+			def self.included(klass); klass.extend(ClassMethods); end
+		
+			module ClassMethods
+				def define_enumerated_attribute_writer_method(name)
+					method_name = "#{name}=".to_sym
+					class_eval do
+						define_method(method_name) {|val| write_enumerated_attribute(name.to_sym, val) }
+          end
+				end
+				
+				def define_enumerated_attribute_reader_method(name)
+					name = name.to_sym
+					class_eval do
+						define_method(name) { read_enumerated_attribute(name) }
+          end
+				end
+			end
+		end
+
+	end
+end

data/lib/enumerated_attribute/integrations/object.rb

@@ -0,0 +1,47 @@
+module EnumeratedAttribute
+	module Integrations
+	
+		module Object
+			def self.included(klass)
+				klass.extend(ClassMethods)
+			end
+
+			def write_enumerated_attribute(name, val)
+				name = name.to_s
+				val = nil if val == ''
+				val = val.to_sym if val
+				unless self.class.enumerated_attribute_allows_value?(name, val)
+					raise(InvalidEnumeration, "nil is not allowed on '#{name}' attribute, set :nil=>true option", caller) unless val
+					raise(InvalidEnumeration, ":#{val} is not a defined enumeration value for the '#{name}' attribute", caller) 
+				end
+				instance_variable_set('@'+name, val)
+			end
+			
+			def read_enumerated_attribute(name)
+				instance_variable_get('@'+name.to_s)
+			end
+
+			module ClassMethods
+				private
+				
+				def define_enumerated_attribute_new_method
+					class_eval do
+						class << self
+							unless method_defined?(:new_without_enumerated_attribute)
+								alias_method :new_without_enumerated_attribute, :new
+								def new(*args, &block)
+									result = new_without_enumerated_attribute(*args)
+									result.initialize_enumerated_attributes
+									yield result if block_given?
+									result
+								end
+							end
+						end
+          end
+				end
+				
+			end
+		
+		end	
+	end
+end

data/lib/enumerated_attribute/method_definition_dsl.rb

@@ -0,0 +1,142 @@
+module EnumeratedAttribute
+
+	class MethodDefinition
+    attr_accessor :method_name, :negated, :argument    
+    
+    def initialize(name, arg, negated=false)
+      @method_name, @negated, @argument = name, negated, arg
+    end
+    
+    def is_predicate_method?; @method_name[-1, 1] == '?'; end
+    def has_method_name?; !!@method_name; end
+    def has_argument?; !!@argument; end
+  end
+  
+  class MethodDefinitionDSL
+    attr_reader :initial_value, :pluralized_name, :decrementor_name, :incrementor_name
+    
+    def initialize(class_obj, descriptor)
+      @class_obj = class_obj
+      @attr_name = descriptor.name
+      @attr_descriptor = descriptor #this is the enums array
+    end
+    
+    #we'll by pass this - they can use it if it helps make code more readable - not enforced - should it be??
+    def define
+    end
+    
+    def is_not(*args)
+      arg = args.first if args.length > 0
+      MethodDefinition.new(nil, arg, true)
+    end
+    alias :isnt :is_not
+    
+    def is(*args)
+      arg = args.first if args.length > 0
+      MethodDefinition.new(nil, arg)
+    end
+
+    def method_missing(methId, *args, &block)
+      meth_name = methId.id2name
+      
+      meth_def = nil
+      if args.size > 0
+        arg = args.first
+        if arg.instance_of?(EnumeratedAttribute::MethodDefinition)
+          if arg.has_method_name?
+            raise_method_syntax_error(meth_name, arg.method_name)
+          end
+          meth_def = arg
+          meth_def.method_name = meth_name
+        else
+          meth_def = MethodDefinition.new(meth_name, arg)
+        end
+      elsif block_given?
+        meth_def = MethodDefinition.new(meth_name, block)
+      else
+        raise_method_syntax_error(meth_name)
+      end
+      evaluate_method_definition(meth_def)
+    end              
+     
+    def init(value)
+      if (!@attr_descriptor.empty? && !@attr_descriptor.include?(value.to_sym))
+        raise(InvalidDefinition, "'#{value}' in method 'init' is not an enumeration value for :#{@attr_name} attribute", caller) 
+      end
+      @initial_value = value
+    end
+
+    def decrementor(value); @decrementor_name = value; end
+    def incrementor(value); @incrementor_name = value; end    
+    def enums_accessor(value); @pluralized_name = value; end
+    alias_method :inc, :incrementor
+    alias_method :dec, :decrementor
+    alias_method :enums, :enums_accessor
+    alias_method :plural, :enums_accessor
+		
+		def label(hash)
+			raise(InvalidDefinition, "label or labels keyword should be followed by a hash of :enum_value=>'label'", caller) unless hash.is_a?(Hash)
+			hash.each do |k,v|
+				raise(InvalidDefinition, "#{k} is not an enumeration value for :#{@attr_name} attribute", caller) unless (k.is_a?(Symbol) && @attr_descriptor.include?(k))
+				raise(InvalidDefinition, "#{v} is not a string. Labels should be strings", caller) unless v.is_a?(String)
+				@attr_descriptor.set_label(k, v)
+			end
+		end
+		alias_method :labels, :label
+    
+    private
+    
+    def raise_method_syntax_error(meth_name, offending_token=nil)
+      suffix = offending_token ? "found '#{offending_token}'" : "found nothing" 
+      followed_by = (meth_name[-1,1] == '?' ? "is_not, an enumeration value, an array of enumeration values, " : "") + "a proc, lambda or code block"
+      raise InvalidDefinition, "'#{meth_name}' should be followed by #{followed_by} -- but #{suffix}"
+    end
+        
+    def evaluate_method_definition(mdef)
+      unless mdef.has_argument?
+        return raise_method_syntax_error(mdef.method_name)
+      end
+      
+      if mdef.is_predicate_method?
+        case mdef.argument
+          when String
+            return create_custom_method_for_symbol_or_string(mdef)
+          when Symbol
+            return create_custom_method_for_symbol_or_string(mdef)
+          when Array
+            return create_custom_method_for_array_of_enums(mdef)
+          when Proc
+            return create_custom_method_for_proc(mdef)            
+        end
+      else #action method
+        if mdef.argument.instance_of?(Proc)
+          return create_custom_method_for_proc(mdef)
+        end
+      end
+      raise_method_syntax_error(mdef.method_name, mdef.argument)
+    end
+    
+    def create_custom_method_for_proc(mdef)
+      @class_obj.send(:define_method, mdef.method_name, mdef.argument)
+    end
+    
+    def create_custom_method_for_symbol_or_string(mdef)
+      if (!@attr_descriptor.empty? && !@attr_descriptor.include?(mdef.argument.to_sym))
+        raise(InvalidDefinition, "'#{mdef.argument}' in method '#{mdef.method_name}' is not an enumeration value for :#{@attr_name} attribute", caller) 
+      end
+      @class_obj.class_eval("def #{mdef.method_name}; @#{@attr_name} #{mdef.negated ? '!=' : '=='} :#{mdef.argument}; end") 
+    end
+
+    def create_custom_method_for_array_of_enums(mdef)
+      if !@attr_descriptor.empty?
+        mdef.argument.each do |m|
+          if !@attr_descriptor.include?(m.to_sym)
+            raise(InvalidDefinition, "'#{m}' in method '#{mdef.method_name}' is not an enumeration value for :#{@attr_name} attribute", caller) 
+          end
+        end
+      end
+      @class_obj.class_eval("def #{mdef.method_name}; #{mdef.negated ? '!' : ''}[:#{mdef.argument.join(',:')}].include?(@#{@attr_name}); end")
+    end
+  end
+	
+end

data/lib/enumerated_attribute/rails_helpers.rb

@@ -0,0 +1,97 @@
+require 'active_record/connection_adapters/abstract/schema_definitions'
+
+if defined?(ActiveRecord)
+	module ActiveRecord
+		module ConnectionAdapters
+			class TableDefinition
+				def column_with_enumerated_attribute(name, type, options = {})
+					type = 'string' if type.to_s == 'enum'
+					column_without_enumerated_attribute(name, type, options)
+				end
+				safe_alias_method_chain :column, :enumerated_attribute
+				
+				def enum(*args)
+					options = args.extract_options!                                      
+					column_names = args                                                   
+					column_names.each { |name| column(name, 'string', options) }  
+				end
+			end
+		end
+	end
+end
+
+#ARGV is used by generators -- if it contains one of these generator commands - add enumeration support
+#unless ((ARGV || []) & ["scaffold", "rspec_scaffold", "nifty_scaffold"]).empty?
+if ((ARGV || []).any?{|o| o =~ /scaffold/ })
+	require 'rails_generator' rescue nil
+  begin
+    require 'rails/generators'
+    require 'rails/generators/generated_attribute'
+  rescue
+  end
+
+	module Rails
+		module Generator
+			class GeneratedAttribute
+				def field_type_with_enumerated_attribute
+					return (@field_type = :enum_select) if type == :enum
+					field_type_without_enumerated_attribute
+				end
+				alias_method_chain :field_type, :enumerated_attribute
+			end
+		end
+	end
+end
+
+if defined?(ActionView::Base)
+	module ActionView
+		module Helpers
+		
+			#form_options_helper.rb
+			module FormOptionsHelper
+				#def select
+				def enum_select(object, method, options={}, html_options={})
+					InstanceTag.new(object, method, self, options.delete(:object)).to_enum_select_tag(options, html_options)
+				end
+			end
+			
+			class InstanceTag
+				def to_enum_select_tag(options, html_options={})
+					choices = []
+					if self.object.respond_to?(:enums)
+						enums = self.object.enums(method_name.to_sym)
+						choices = enums ? enums.select_options : []
+						if (value = self.object.__send__(method_name.to_sym))
+							options[:selected] ||= value.to_s
+						else
+              options[:include_blank] = enums.allows_nil? if options[:include_blank].nil?
+						end
+					end
+					to_select_tag(choices, options, html_options)
+				end
+				
+				#initialize record_name, method, self
+				def to_tag_with_enumerated_attribute(options={})
+					#look for an enum
+					if (column_type == :string && 
+						self.object.class.respond_to?(:has_enumerated_attribute?) &&
+						self.object.class.has_enumerated_attribute?(method_name.to_sym)) 
+						to_enum_select_tag(options)
+					else
+						to_tag_without_enumerated_attribute(options)
+					end
+				end
+				alias_method_chain :to_tag, :enumerated_attribute
+			end
+			
+			class FormBuilder
+				def enum_select(method, options={}, html_options={})
+					@template.enum_select(@object_name, method, objectify_options(options), @default_options.merge(html_options))
+				end
+			end
+			
+		end
+	end
+end
+
+