edave-enumerated_attribute 0.2.18

data/Rakefile

@@ -0,0 +1,30 @@
+#require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/contrib/sshpublisher'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+
+    s.name = 'edave-enumerated_attribute'
+    s.platform = Gem::Platform::RUBY
+    s.description = 'Enumerated model attributes and view helpers'
+    s.summary = 'Add enumerated attributes to your models and expose them in drop-down lists in your views'
+
+    s.add_dependency('meta_programming', '>= 0.2.1')
+
+    exclude_folders = 'spec/rails/{doc,lib,log,nbproject,tmp,vendor,test}'
+    exclude_files = FileList['**/*.log'] + FileList[exclude_folders+'/**/*'] + FileList[exclude_folders]
+    s.files = FileList['{examples,lib,tasks,spec}/**/*'] + %w(CHANGELOG.rdoc init.rb LICENSE Rakefile README.rdoc .gitignore) - exclude_files
+    s.require_path = 'lib'
+    s.has_rdoc = true
+    s.test_files = Dir['spec/*_spec.rb']
+
+    s.author = 'Jeff Patmon'
+    s.email = 'jpatmon@gmail.com'
+    s.homepage = 'http://github.com/jeffp/enumerated_attribute/tree/master'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/init.rb

@@ -0,0 +1 @@
+require 'enumerated_attribute'

data/lib/enumerated_attribute.rb

@@ -0,0 +1,24 @@
+gem 'meta_programming', '>= 0.2.0'
+require 'meta_programming'
+require 'enumerated_attribute/attribute'
+
+module EnumeratedAttribute
+
+	module MacroMethods
+		
+		def enumerated_attribute(*args, &block)
+			class << self
+				include EnumeratedAttribute::Attribute
+			end
+			create_enumerated_attribute(*args, &block)
+		end
+		alias_method :enum_attr, :enumerated_attribute
+		
+	end
+	
+end
+
+Class.class_eval do
+  include EnumeratedAttribute::MacroMethods
+end
+

data/lib/enumerated_attribute/attribute.rb

@@ -0,0 +1,79 @@
+require 'enumerated_attribute/attribute/attribute_descriptor'
+require 'enumerated_attribute/attribute/arguments'
+require 'enumerated_attribute/attribute/instance_methods'
+require 'enumerated_attribute/attribute/class_methods'
+require 'enumerated_attribute/method_definition_dsl'
+require 'enumerated_attribute/integrations'
+require 'enumerated_attribute/rails_helpers'
+require 'ostruct'
+
+module EnumeratedAttribute
+
+	class EnumeratedAttributeError < StandardError; end
+	class IntegrationError < EnumeratedAttributeError; end
+	class InvalidEnumeration < EnumeratedAttributeError; end
+	class InvalidDefinition < EnumeratedAttributeError; end
+	class AmbiguousMethod < EnumeratedAttributeError; end
+
+  module Attribute
+    private
+
+    def create_enumerated_attribute(*args, &block)
+      return if args.empty?
+      config = Arguments.parse_enum_attr_arguments(args)
+
+      class_eval do
+        @enumerated_attributes ||= {}
+        @enumerated_attributes[config.attr_symbol] = AttributeDescriptor.new(config.attr_symbol, config.enums, config.opts)
+
+        unless @integration_map
+          @integration_map = Integrations.find_integration_map(self)
+          @integration_map[:aliasing].each do |p|
+            alias_method(p.first, p.last)
+          end
+          include(EnumeratedAttribute::Integrations::Default)
+          include(@integration_map[:module]) if @integration_map[:module]
+
+          self.extend ClassMethods
+          include InstanceMethods
+        end
+      end
+
+      #create accessors
+      define_enumerated_attribute_reader_method(config.attr_symbol) unless (config.opts.key?(:reader) && !config.opts[:reader])
+      define_enumerated_attribute_writer_method(config.attr_symbol) unless (config.opts.key?(:writer) && !config.opts[:writer])
+      define_enumerated_attribute_new_method
+
+      #create state and action methods from block
+      config.initial_value = config.opts[:init] || config.initial_value
+      if block_given?
+        m = EnumeratedAttribute::MethodDefinitionDSL.new(self, self.enumerated_attributes(false)[config.attr_symbol]) #attr_name, enums)
+        m.instance_eval(&block)
+        config.initial_value = m.initial_value || config.initial_value
+        config.plural_name = m.pluralized_name || config.plural_name
+        config.decrementor = m.decrementor_name || config.decrementor
+        config.incrementor = m.incrementor_name || config.incrementor
+      end
+
+      #define the enum values accessor
+      class_eval do
+        @enumerated_attributes ||={}
+        @enumerated_attributes[config.attr_symbol].init_value = config.initial_value if config.initial_value
+
+        define_method(config.plural_name.to_sym) { self.class.enumerated_attributes[config.attr_symbol]}
+        define_method(config.incrementor.to_sym) do
+          z = self.class.enumerated_attributes[config.attr_symbol].enums
+          index = z.index(read_enumerated_attribute(config.attr_symbol))
+          write_enumerated_attribute(config.attr_symbol, z[index >= z.size-1 ? 0 : index+1])
+        end
+        define_method(config.decrementor.to_sym) do
+          z = self.class.enumerated_attributes[config.attr_symbol].enums
+          index = z.index(read_enumerated_attribute(config.attr_symbol))
+          write_enumerated_attribute(config.attr_symbol, z[index > 0 ? index-1 : z.size-1])
+        end
+      end
+      refresh_enumerated_attributes
+    end
+  end
+		
+end

data/lib/enumerated_attribute/attribute/arguments.rb

@@ -0,0 +1,48 @@
+module EnumeratedAttribute
+	module Attribute
+    module Arguments
+      def self.validate_enum_attr_arguments(config)
+				raise(InvalidDefinition, 'second argument of enumerated_attribute/enum_attr is not an array of symbols or strings representing the enum values', caller) if config.enums.empty?
+      end
+      def self.init_incrementor_decrementor_method_names(config)
+				config.incrementor = config.opts[:incrementor] || config.opts[:inc] || "#{config.attr_name}_next"
+				config.decrementor = config.opts[:decrementor] || config.opts[:dec] || "#{config.attr_name}_previous"
+      end
+      def self.init_plural_name(config)
+				config.plural_name = config.opts[:plural] || config.opts[:enums_accessor] || config.opts[:enums] || begin
+          case
+					when config.attr_name =~ /[aeiou]y$/
+						"#{config.attr_name}s"
+					when config.attr_name =~ /y$/
+						config.attr_name.sub(/y$/, 'ies')
+					when config.attr_name =~ /(sh|ch|x|s)$/
+						"#{config.attr_name}es"
+					else
+						"#{config.attr_name}s"
+					end
+				end
+      end
+      def self.process_enums_for_initial_value(config)
+        config.initial_value = nil
+				config.enums = config.enums.map{|v| (v =~ /^\^/ ? (config.initial_value ||= v[1, v.length-1].to_sym) : v.to_sym )}
+      end
+
+      def self.parse_enum_attr_arguments(args)
+        config = OpenStruct.new
+        config.attr_name = args[0].to_s
+        config.attr_symbol = config.attr_name.to_sym
+        config.enums = (args[1] && args[1].is_a?(Array) ? args[1] : [])
+        index = config.enums.empty? ? 1 : 2
+        config.opts = (args[index] && args[index].is_a?(Hash) ? args[index] : {})
+
+        validate_enum_attr_arguments(config)
+        init_plural_name(config)
+        init_incrementor_decrementor_method_names(config)
+        process_enums_for_initial_value(config)
+
+        config
+      end
+    end
+  end
+
+end

data/lib/enumerated_attribute/attribute/attribute_descriptor.rb

@@ -0,0 +1,51 @@
+
+module EnumeratedAttribute
+	module Attribute
+		class AttributeDescriptor < Array		
+			attr_reader :name
+			attr_accessor :init_value
+			
+			def initialize(name, enums=[], opts={})
+				super enums
+				@name = name
+				@options = opts
+				@labels_hash = Hash[*self.collect{|e| [e, e.to_s.gsub(/_/, ' ').squeeze(' ').capitalize]}.flatten]
+			end
+			
+			def allows_nil?
+				@options.key?(:nil) ? @options[:nil] : true
+			end
+			def allows_value?(value)
+				self.include?(value.to_sym)
+			end
+				
+			def enums
+				self
+			end
+			def label(value)
+				@labels_hash[value]
+			end
+			def labels
+				@labels_array ||= self.map{|e| @labels_hash[e]}
+			end
+			def hash
+				@labels_hash
+			end
+			def select_options
+				@select_options ||= self.map{|e| [@labels_hash[e], e.to_s]}
+			end
+			
+			def set_label(enum_value, label_string)
+				reset_labels
+				@labels_hash[enum_value.to_sym] = label_string
+			end
+			
+			protected
+			def reset_labels
+				@labels_array = nil
+				@select_options = nil
+			end
+			
+		end
+	end
+end

data/lib/enumerated_attribute/attribute/class_methods.rb

@@ -0,0 +1,45 @@
+module EnumeratedAttribute
+  module Attribute
+    module ClassMethods
+      def refresh_enumerated_attributes
+        @all_enumerated_attributes_cache = nil
+      end
+      def enumerated_attributes(all=true)
+        return @enumerated_attributes unless all
+        return @all_enumerated_attributes_cache if @all_enumerated_attributes_cache
+        @all_enumerated_attributes_cache = @enumerated_attributes ?  @enumerated_attributes.dup : {}
+        klass = self.superclass
+        while (klass)
+          if (klass.respond_to?(:enumerated_attributes))
+            if (sub_enums = klass.enumerated_attributes)
+              @all_enumerated_attributes_cache = sub_enums.merge @all_enumerated_attributes_cache
+              break
+            end
+          end
+          klass = klass.superclass
+        end
+        @all_enumerated_attributes_cache
+      end
+
+      def has_enumerated_attribute?(name)
+        !name.nil? && !!self.enumerated_attributes.key?(name.to_sym)
+      end
+      def enumerated_attribute_allows_nil?(name)
+        (descriptor = self.enumerated_attributes[name.to_sym]) && descriptor.allows_nil?
+      end
+      def enumerated_attribute_allows_value?(name, value)
+        return (false) unless (descriptor = self.enumerated_attributes[name.to_sym])
+        return descriptor.allows_nil? if (value == nil || value == '')
+        descriptor.allows_value?(value)
+      end
+
+      def define_enumerated_attribute_custom_method(symbol, attr_name, value, negated)
+        define_method symbol do
+          ival = read_enumerated_attribute(attr_name)
+          negated ? ival != value : ival == value
+        end
+      end
+
+    end
+  end
+end

data/lib/enumerated_attribute/attribute/instance_methods.rb

@@ -0,0 +1,96 @@
+module EnumeratedAttribute
+  module Attribute
+    module InstanceMethods
+      def self.included(base)
+
+        method_missing_suffix = "enumerated_attribute_#{base.name.gsub(/.+::/,'')}_#{base.hash.abs}".to_sym
+        define_method("method_missing_with_#{method_missing_suffix}") do |methId, *args|
+          return self.__send__(methId) if define_enumerated_attribute_dynamic_method(methId)
+          self.__send__("method_missing_without_#{method_missing_suffix}", methId, *args)
+        end
+
+        respond_to_suffix = "enumerated_attribute_#{base.name.gsub(/.+::/,'')}_#{base.hash.abs}".to_sym
+        base.class_eval %{
+          def respond_to_with_#{respond_to_suffix}?(method, include_private=false)
+            self.respond_to_without_#{respond_to_suffix}?(method, include_private) ||
+              (!!parse_dynamic_method_parts!(method.to_s) rescue false)
+          end
+        }, __FILE__, __LINE__
+
+        base.safe_alias_method_chain :method_missing, method_missing_suffix
+        base.safe_alias_method_chain :respond_to?, respond_to_suffix
+
+      end
+
+      def enums(attr)
+        self.class.enumerated_attributes[attr.to_sym]
+      end
+
+
+      def initialize_enumerated_attributes(only_if_nil = false)
+        self.class.enumerated_attributes.each do |k,v|
+          self.write_enumerated_attribute(k, v.init_value) unless (only_if_nil && read_enumerated_attribute(k) != nil)
+        end
+      end
+
+      private
+
+      def parse_dynamic_method_parts!(meth_name)
+        return(nil) unless meth_name[-1, 1] == '?'
+
+        middle = meth_name.chop #remove the ?
+
+        attr = nil
+        self.class.enumerated_attributes.keys.each do |name|
+          if middle.sub!(Regexp.new("^"+name.to_s), "")
+            attr = name; break
+          end
+        end
+
+        value = nil
+        attr_sym = attr ? attr.to_sym : nil
+        if (descriptor = self.class.enumerated_attributes[attr_sym])
+          descriptor.enums.each do |v|
+            if middle.sub!(Regexp.new(v.to_s+"$"), "")
+              value = v; break
+            end
+          end
+        else
+          #search through enum values one at time and identify any ambiguities
+          self.class.enumerated_attributes.each do |attr_key,descriptor|
+            descriptor.enums.each do|v|
+              if middle.match(v.to_s+"$")
+                raise(AmbiguousMethod, meth_name+" is ambiguous, use something like "+attr_sym.to_s+(middle[0,1]=='_'? '' : '_')+middle+"? or "+attr_key.to_s+(middle[0,1]=='_'? '' : '_')+middle+"?", caller) if attr_sym
+                attr_sym = attr_key
+                value = v
+              end
+            end
+          end
+          return (nil) unless attr_sym
+          attr = attr_sym.to_s
+          middle.sub!(Regexp.new(value.to_s+"$"), "")
+        end
+
+        unless value #check for nil?
+          return (nil) unless middle.sub!(Regexp.new('nil$'), "")
+          value = nil
+        end
+
+        [attr, middle, value]
+      end
+
+      def define_enumerated_attribute_dynamic_method(methId)
+        meth_name = methId.id2name
+        parts = parse_dynamic_method_parts!(meth_name)
+        return(false) unless parts
+
+        negated = !!parts[1].downcase.match(/(^|_)not_/)
+        value = parts[2] ? parts[2].to_sym : nil
+        self.class.define_enumerated_attribute_custom_method(methId, parts[0], value, negated)
+
+        true
+      end
+
+    end
+  end
+end

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,114 @@
+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 = {}
+          attribute_names.each_with_index{|name, idx| attributes[name] = has_enumerated_attribute?(name) ? arguments[idx].to_s : arguments[idx]}
+          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
+              unless private_method_defined?(:method_missing_without_enumerated_attribute)
+                define_chained_method(:method_missing, :enumerated_attribute) do |method_id, *arguments|
+                  arguments = arguments.map{|arg| arg.is_a?(Symbol) ? arg.to_s : arg }
+                  method_missing_without_enumerated_attribute(method_id, *arguments)
+                end
+              end
+						end
+          end
+				end
+			end
+		end	
+	end
+end