jeffp-enumerated_attribute 0.1.7 → 0.2.0.2

data/lib/enumerated_attribute/attribute/attribute_descriptor.rb

@@ -0,0 +1,50 @@
+
+module EnumeratedAttribute
+	module Attribute
+		class AttributeDescriptor < Array		
+			attr_reader :name
+			
+			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
+			
+			private
+			def reset_labels
+				@labels_array = nil
+				@select_options = nil
+			end
+			
+		end
+	end
+end

data/lib/enumerated_attribute/integrations/active_record.rb

@@ -9,6 +9,7 @@ module EnumeratedAttribute
 			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)
@@ -17,6 +18,7 @@ module EnumeratedAttribute
 				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)
@@ -24,10 +26,11 @@ module EnumeratedAttribute
 				#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 && self.class.has_enumerated_attribute?(name))
+				val = val.to_sym if !!val
 				val
 			end
 			
@@ -48,7 +51,7 @@ module EnumeratedAttribute
 			
 			def attributes
 				super.map do |k,v|
-					self.class.has_enumerated_attribute?(k) ? v.to_sym : v
+					self.class.has_enumerated_attribute?(k) ? @@enumerated_attributes[k].cast_enum_symbol(v) : v
 				end
 			end
 			
@@ -66,7 +69,7 @@ module EnumeratedAttribute
 					attributes = super
 					attributes.each { |k,v| attributes[k] = v.to_s if has_enumerated_attribute?(k) }
 					attributes
-				end			
+				end
 				
 				def instantiate(record)
 					object = super(record)

data/lib/enumerated_attribute/integrations/object.rb

@@ -8,6 +8,7 @@ module EnumeratedAttribute
 
 			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
@@ -17,7 +18,7 @@ module EnumeratedAttribute
 			end
 			
 			def read_enumerated_attribute(name)
-				return instance_variable_get('@'+name.to_s)
+				instance_variable_get('@'+name.to_s)
 			end
 
 			module ClassMethods

data/lib/enumerated_attribute/method_definition_dsl.rb

@@ -15,10 +15,10 @@ module EnumeratedAttribute
   class MethodDefinitionDSL
     attr_reader :initial_value, :pluralized_name, :decrementor_name, :incrementor_name
     
-    def initialize(class_obj, attr_name, values=[])
+    def initialize(class_obj, descriptor)
       @class_obj = class_obj
-      @attr_name = attr_name
-      @attr_values = values      
+      @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??
@@ -60,7 +60,7 @@ module EnumeratedAttribute
     end              
      
     def init(value)
-      if (!@attr_values.empty? && !@attr_values.include?(value.to_sym))
+      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
@@ -69,10 +69,20 @@ module EnumeratedAttribute
     def decrementor(value); @decrementor_name = value; end
     def incrementor(value); @incrementor_name = value; end    
     def enums_accessor(value); @pluralized_name = value; end
-    alias :inc :incrementor
-    alias :dec :decrementor
-    alias :enums :enums_accessor
-    alias :plural :enums_accessor
+    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
     
@@ -111,16 +121,16 @@ module EnumeratedAttribute
     end
     
     def create_custom_method_for_symbol_or_string(mdef)
-      if (!@attr_values.empty? && !@attr_values.include?(mdef.argument.to_sym))
+      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_values.empty?
+      if !@attr_descriptor.empty?
         mdef.argument.each do |m|
-          if !@attr_values.include?(m.to_sym)
+          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

data/lib/enumerated_attribute/rails_helpers.rb

@@ -0,0 +1,73 @@
+
+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
+				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
+
+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] ||= true
+						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
+
+

data/spec/active_record/active_record_spec.rb

@@ -1,9 +1,48 @@
 require 'test_in_memory'
-require 'enumerated_attribute'
 require 'active_record'
+require 'enumerated_attribute'
 require 'race_car'
 
 describe "RaceCar" do
+
+	it "should have default labels for :gear attribute" do
+		labels_hash = {:reverse=>'Reverse', :neutral=>'Neutral', :first=>'First', :second=>'Second', :over_drive=>'Over drive'}
+		labels = ['Reverse', 'Neutral', 'First', 'Second', 'Over drive']
+		select_options = [['Reverse', 'reverse'], ['Neutral', 'neutral'], ['First', 'first'], ['Second', 'second'], ['Over drive', 'over_drive']]
+		r=RaceCar.new
+		r.gears.labels.should == labels
+		labels_hash.each do |k,v|
+			r.gears.label(k).should == v
+		end
+		r.gears.hash.should == labels_hash
+		r.gears.select_options.should == select_options
+	end
+	
+	it "should retrieve :gear enums through enums method" do
+		r=RaceCar.new
+		r.enums(:gear).should == r.gears
+	end
+
+	it "should return a Symbol type from reader methods" do
+		r=RaceCar.new
+		r.gear.should be_an_instance_of(Symbol)
+	end
+	
+	it "should increment and decrement :gear attribute correctly" do
+		r=RaceCar.new
+		r.gear = :neutral
+		r.gear_next.should == :first
+		r.gear_next.should == :second
+		r.gear_next.should == :over_drive
+		r.gear_next.should == :reverse
+		r.gear_next.should == :neutral
+		r.gear.should == :neutral
+		r.gear_previous.should == :reverse
+		r.gear_previous.should == :over_drive
+		r.gear_previous.should == :second
+		r.gear_previous
+		r.gear.should == :first
+	end
 	
 	it "should have dynamic predicate methods for :gear attribute" do
 		r=RaceCar.new
@@ -55,13 +94,21 @@ describe "RaceCar" do
 		r.choke.should == :medium
 	end
 	
-	it "should initialize using parameter hash" do
+	it "should initialize using parameter hash with symbol keys" do
 		r=RaceCar.new(:name=>'FastFurious', :gear=>:second, :lights=>'on', :choke=>:medium)
 		r.gear.should == :second
 		r.lights.should == 'on'
 		r.choke.should == :medium
 	end
 	
+	it "should initialize using parameter hash with string keys" do
+		r=RaceCar.new({'name'=>'FastFurious', 'gear'=>'second', 'lights'=>'on', 'choke'=>'medium'})
+		r.gear.should == :second
+		r.lights.should == 'on'
+		r.choke.should == :medium
+	end
+	
+	
 	it "should convert non-column enumerated attributes from string to symbols" do
 		r=RaceCar.new
 		r.choke = 'medium'

data/spec/active_record/association_test_classes.rb

@@ -0,0 +1,40 @@
+
+class Company < ActiveRecord::Base
+	has_one :license
+	has_many :employees
+	has_many :contract_workers
+	has_many :contractors, :through=>:contract_workers
+	enum_attr :status, %w(s_corp c_corp llc), :nil=>true
+end
+class Employee < ActiveRecord::Base
+  belongs_to :company
+	enum_attr :status, %w(full_time part_time suspended), :nil=>true
+end
+class License < ActiveRecord::Base
+  belongs_to :company
+	enum_attr :status, %w(^current expired)
+end
+class Contractor < ActiveRecord::Base
+	has_many :contract_workers
+	has_many :companies, :through=>:contract_workers
+	enum_attr :status, %w(^available unavailable)
+end
+class ContractWorker < ActiveRecord::Base
+  belongs_to :company
+	belongs_to :contractor
+	enum_attr :status, %w(unfresh ^unfresh) #i don't know what to put here
+end
+
+#polymorphic
+class Comment < ActiveRecord::Base
+	belongs_to :document, :polymorphic=>true
+	enum_attr :status, %w(^unflagged flagged)
+end
+class Article < ActiveRecord::Base
+	has_one :comment, :as=>:document
+	enum_attr :status, %w(^unreviewed accepted)
+end
+class Image < ActiveRecord::Base
+	has_one :comment, :as=>:document
+	enum_attr :status, %w(^unreviewed accepted)
+end

data/spec/active_record/associations_spec.rb

@@ -0,0 +1,130 @@
+require 'test_in_memory'
+require 'enumerated_attribute'
+require 'active_record'
+require 'association_test_classes'
+
+module TestVariables
+	def company_name; 'Company A'; end
+end
+
+describe "Polymorphic associations" do
+	include TestVariables
+	
+	it "should retrieve enum'ed attribute for articles and images of a comment" do
+		c1 = Comment.new(:comment=>'i like it')
+		c1.document = Article.create!(:name=>'Birds of a Feather', :status=>:accepted)
+		c1.save!
+		c1.status.should == :unflagged
+		
+		c2 = Comment.new(:comment=>'i hate it', :status => :flagged)
+		c2.document = Image.create!(:name=>'Martian Landscape', :status=>:unreviewed)
+		c2.save!
+		c2.status.should == :flagged
+		
+		Comment.find(c1.id).document.status.should == :accepted
+		Comment.find(c2.id).document.status.should == :unreviewed
+
+	end
+	
+	it "should retrieve enum'ed attribute for comments on articles and images" do
+		a = Article.create!(:name=>'Swimming with Whales', :status=>:accepted)
+		a.create_comment(:comment=>'i like it', :status=>:unflagged)
+		a.save!
+		
+		i = Image.create!(:name=>'Mountain Climbing', :status=>:unreviewed)
+		i.comment = Comment.create!(:comment=>'i do not like it', :status=>:flagged)
+		i.save!
+		
+		Image.find(i.id).comment.status.should == :flagged
+		Article.find(a.id).comment.status.should == :unflagged
+		
+	end
+	
+end
+
+describe "Basic Associations" do
+	include TestVariables
+
+	it "should retrieve enum'ed status for its license" do
+		c = Company.new(:status=>:llc, :name=>company_name)
+		c.save!
+		c.create_license(:status=>:current)
+		
+		r = Company.find(c.id)
+		lic = r.license
+		r.status.should == :llc
+		lic.status.should == :current
+	end
+	
+	it "should retrieve enum'ed status for multiple employees" do
+		c=Company.new(:status=>:llc, :name=>company_name)
+		c.save!
+		c.employees.create!(:status=>:full_time, :name=>'edward')
+		c.employees.create!(:status=>:suspended, :name=>'tina')
+		
+		r=Company.find(c.id)
+		r.employees.find_by_name('edward').status.should == :full_time		
+		r.employees.find_by_name('tina').status.should == :suspended		
+		Employee.delete_all
+	end
+	
+	it "should retrieve enum'ed status for multiple contractors" do
+		c=Company.new(:status=>:llc, :name=>company_name)
+		c.save!
+		c1 = Contractor.new(:status=>:available, :name=>'john')
+		c2 = Contractor.new(:status=>:unavailable, :name=>'sally')
+		c.contractors << c1
+		c.contractors << c2
+		
+		r=Company.find(c.id)
+		r.contractors.find_by_name('sally').status.should == :unavailable
+		r.contractors.find_by_name('john').status.should == :available
+		Contractor.delete_all
+		ContractWorker.delete_all
+	end
+end
+
+describe "License" do
+	include TestVariables
+  it "should retrieve the status for the company" do
+		Company.delete_all
+		License.delete_all
+		lic = License.create!(:status=>:expired)
+		lic.company = Company.create!(:name=>company_name, :status=>:llc)
+		lic.save!
+		
+		License.find(lic.id).company.status.should == :llc
+	end
+end
+
+describe "Contractor" do
+	include TestVariables
+	it "should retrieve enum'ed status from multiple companies" do
+		Company.delete_all
+		Contractor.delete_all
+		ContractWorker.delete_all
+		c = Contractor.create!(:name=>'jack', :status=>:available)
+		
+		c1 = Company.create!(:name=>company_name, :status=>:s_corp)
+		c2 = Company.create!(:name=>'other company', :status=>:llc)
+		c.companies << c1 << c2
+		
+		j = Contractor.find(c.id)
+		j.companies.find_by_name('other company').status.should == :llc
+		j.companies.find_by_name(company_name).status.should == :s_corp		
+	end
+end
+
+describe "Employee" do
+	include TestVariables
+	it "should retrieve enum'ed status from the company" do
+		Company.delete_all
+		Employee.delete_all
+		e = Employee.create!(:name=>'juanita', :status=>:part_time)
+		e.company = Company.create!(:name=>company_name, :status=>:c_corp)
+		e.save!
+		
+		emp = Employee.find(e.id)
+		emp.company.status.should == :c_corp
+	end
+end