enumerated_attribute 0.2.7

data/Rakefile

@@ -0,0 +1,104 @@
+#require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+require 'gem_version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'enumerated_attribute'
+  s.version = GemVersion.next_version
+  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
+ 
+require 'spec/version'
+require 'spec/rake/spectask'
+
+desc "Run specs"
+
+namespace :spec do
+	task :default=>:all
+	Spec::Rake::SpecTask.new(:object) do |t|
+		t.spec_files = FileList['spec/*_spec.rb']
+		t.libs << 'lib' << 'spec'
+		t.rcov = false
+		t.spec_opts = ['--options', 'spec/spec.opts']
+		#t.rcov_dir = 'coverage'
+		#t.rcov_opts = ['--exclude', "kernel,load-diff-lcs\.rb,instance_exec\.rb,lib/spec.rb,lib/spec/runner.rb,^spec/*,bin/spec,examples,/gems,/Library/Ruby,\.autotest,#{ENV['GEM_HOME']}"]
+	end
+=begin
+	Spec::Rake::SpecTask.new(:sub) do |t|
+		t.spec_files = FileList['spec/inheritance_spec.rb']
+		t.libs << 'lib' << 'spec'
+		t.rcov = false
+		t.spec_opts = ['--options', 'spec/spec.opts']
+	end
+	Spec::Rake::SpecTask.new(:poro) do |t|
+		t.spec_files = FileList['spec/poro_spec.rb']
+		t.libs << 'lib' << 'spec'
+		t.rcov = false
+		t.spec_opts = ['--options', 'spec/spec.opts']
+	end
+=end	
+  desc "Run ActiveRecord integration specs"
+	Spec::Rake::SpecTask.new(:ar) do |t|
+		t.spec_files = FileList['spec/active_record/*_spec.rb']
+		t.libs << 'lib' << 'spec/active_record'
+		t.spec_opts = ['--options', 'spec/spec.opts']    
+		t.rcov = false
+	end
+	Spec::Rake::SpecTask.new(:forms) do |t|
+		t.spec_files = FileList['spec/rails/spec/integrations/*_spec.rb']
+		t.libs << 'lib' << 'spec/rails/spec'
+		t.spec_opts = ['--options', 'spec/spec.opts']    
+		t.rcov = false
+	end
+#	Spec::Rake::SpecTask.new(:associations) do |t|
+#		t.spec_files = FileList['spec/active_record/associations_spec.rb']
+#		t.libs << 'lib' << 'spec/active_record'
+#		t.rcov = false
+#	end
+	desc "Run all specs"
+	task :all=>[:object, :ar, :forms] 
+end
+
+
+desc "Generate documentation for the #{spec.name} plugin."
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = spec.name
+  #rdoc.template = '../rdoc_template.rb'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc', 'CHANGELOG.rdoc', 'LICENSE', 'lib/**/*.rb')
+end
+ 
+desc 'Generate a gemspec file.'
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+  GemVersion.increment_version
+  GemVersion.commit_and_push
+end
+ 
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = RUBY_PLATFORM =~ /mswin/ ? false : true
+  p.need_zip = true
+end
+
+Dir['tasks/**/*.rake'].each {|rake| load rake}

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,78 @@
+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
+    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,42 @@
+module EnumeratedAttribute
+  module Attribute
+    module ClassMethods
+      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}_#{base.hash}".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}_#{base.hash}".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
+        }
+
+        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