edave-enumerated_attribute 0.2.18

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,99 @@
+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/ })
+	begin
+    require 'rails/generators'
+    require 'rails/generators/generated_attribute'
+  rescue
+  rescue Exception => ex
+  end
+
+	module Rails
+		module Generators
+			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
+				if respond_to?(:to_tag)
+  				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
+			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

@@ -0,0 +1,384 @@
+require 'test_in_memory'
+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
+		r.gear = :second
+		r.gear_is_in_second?.should be_true
+		r.gear_not_in_second?.should be_false
+		r.gear_is_nil?.should be_false
+		r.gear_is_not_nil?.should be_true
+	end
+	
+	it "should have working dynamic predicate methods on retrieved objects" do
+		r=RaceCar.new
+		r.gear = :second
+		r.save!
+		
+		s=RaceCar.find r.id
+		s.should_not be_nil
+		s.gear_is_in_second?.should be_true
+		s.gear_is_not_in_second?.should be_false
+		s.gear_is_nil?.should be_false
+		s.gear_is_not_nil?.should be_true
+	end
+
+  it "should be created and found with dynamic find or creator method" do
+    s = RaceCar.find_or_create_by_name_and_gear('specialty', :second)
+    s.should_not be_nil
+    s.gear.should == :second
+    s.name.should == 'specialty'
+
+    s0 = RaceCar.find_or_create_by_name_and_gear('specialty', :second)
+    s0.gear.should == :second
+    s0.id.should == s.id
+  end
+  it "should be initialized with dynamic find or initialize method" do
+    s = RaceCar.find_or_initialize_by_name_and_gear('myspecialty', :second)
+    s.should_not be_nil
+    s.gear.should == :second
+    s.name.should == 'myspecialty'
+    lambda { s.save! }.should_not raise_exception
+
+    s0 = RaceCar.find_or_initialize_by_name_and_gear('myspecialty', :second)
+    s0.gear.should == :second
+    s0.id.should == s.id
+  end
+	it "should find record using dynamic finder by enumerated column :gear attributes" do
+		r=RaceCar.new
+		r.gear = :second
+		r.name = 'special'
+		r.save!
+		
+		s=RaceCar.find_by_gear_and_name(:second, 'special')
+		s.should_not be_nil
+		s.id.should == r.id
+	end
+	
+	it "should initialize according to enumerated attribute definitions" do
+		r = RaceCar.new
+		r.gear.should == :neutral
+		r.choke.should == :none
+	end
+	
+	it "should create new instance using block" do
+		r = RaceCar.new do |r|
+			r.gear = :first
+			r.choke = :medium
+			r.lights = 'on'
+		end
+		r.gear.should == :first
+		r.lights.should == 'on'
+		r.choke.should == :medium
+	end
+	
+	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'
+		r.choke.should == :medium
+		r.save!		
+	end
+	
+	it "should convert enumerated column attributes from string to symbols" do
+		r=RaceCar.new
+		r.gear = 'second'
+		r.gear.should == :second
+		r.save!
+
+		s=RaceCar.find r.id
+		s.gear.should == :second
+	end
+	
+	it "should not convert non-enumerated column attributes from string to symbols" do
+		r=RaceCar.new
+		r.lights = 'off'
+		r.lights.should == 'off'
+		r.save!
+		
+		s=RaceCar.find r.id
+		s.lights.should == 'off'
+	end	
+
+	it "should raise InvalidEnumeration when parametrically initialized with :gear=>:drive" do
+		r=RaceCar.new
+		lambda{ r.gear= :drive}.should raise_error(EnumeratedAttribute::InvalidEnumeration)
+	end
+	
+	it "should raise InvalidEnumeration when parametrically initialized with :choke=>:all" do
+		r=RaceCar.new
+		lambda{ r.choke= :all}.should raise_error(EnumeratedAttribute::InvalidEnumeration)
+	end
+	
+	it "should return non-column enumerated attributes from [] method" do
+		r = RaceCar.new
+		r[:choke].should == :none
+	end
+	
+	it "should return enumerated column attributes from [] method" do
+		r=RaceCar.new
+		r.gear = :neutral
+		r[:gear].should == :neutral
+	end
+	
+	it "should set non-column enumerated attributes with []= method" do
+		r=RaceCar.new
+		r[:choke] = :medium
+		r.choke.should == :medium
+	end
+	
+	it "should set enumerated column attriubtes with []= method" do
+		r=RaceCar.new
+		r[:gear] = :second
+		r.gear.should == :second
+	end
+	
+	it "should raise InvalidEnumeration when setting enumerated column attribute with []= method" do
+		r=RaceCar.new
+		lambda{ r[:gear]= :drive }.should raise_error(EnumeratedAttribute::InvalidEnumeration)
+	end
+	
+	it "should set and retrieve string for non-enumerated column attributes with []=" do
+		r=RaceCar.new
+		r[:lights] = 'on'
+		r.lights.should == 'on'
+		r[:lights].should == 'on'
+	end
+	
+	it "should set and retrieve symbol for non-enumerated column attributes with []=" do
+		r=RaceCar.new
+		r[:lights] = :on
+		r.lights.should == :on
+		r[:lights].should == :on
+	end
+
+	it "should raise InvalidEnumeration for invalid enum passed to attributes=" do
+		r=RaceCar.new
+		lambda { r.attributes = {:lights=>'off', :gear =>:drive} }.should raise_error(EnumeratedAttribute::InvalidEnumeration)
+	end
+
+=begin
+	#do not write symbols to enumerated column attributes using write_attribute
+	#do not user read_attribute to read an enumerated column attribute
+	it "should write enumeration with write_attribute" do
+		r=RaceCar.new
+		r.write_attribute(:gear, :first)
+		r.gear.should == :first
+		r.save!
+		
+		s=RaceCar.find r.id
+		s.gear.should == :first
+		s.write_attribute(:gear, :second)
+		s.save!
+		
+		t=RaceCar.find s.id
+		t.gear.should == :second
+	end
+	
+	it "should raise error when setting enumerated column attribute to invalid enum using write_attribute" do
+		r=RaceCar.new
+		lambda { r.write_attribute(:gear, :yo) }.should raise_error
+	end	
+=end
+	
+	it "should retrieve symbols for enumerations from ActiveRecord :attributes method" do
+		r=RaceCar.new
+		r.gear = :second
+		r.choke = :medium
+		r.lights = 'on'
+		r.save!
+		
+		s = RaceCar.find(r.id)
+		s.attributes['gear'].should == :second
+		s.attributes['lights'].should == 'on'
+	end
+	
+	it "should update_attribute for enumerated column attribute" do
+		r=RaceCar.new
+		r.gear = :first
+		r.save!
+		r.update_attribute(:gear, :second)
+		r.gear.should == :second
+		
+		s=RaceCar.find r.id
+		s.gear.should == :second
+	end
+	
+	it "should update_attribute for non-enumerated column attribute" do
+		r=RaceCar.new
+		r.lights = 'on'
+		r.save!
+		r.update_attribute(:lights, 'off')
+		r.lights.should == 'off'
+		
+		s=RaceCar.find r.id
+		s.lights.should == 'off'
+	end
+	
+	it "should update_attributes for both non- and enumerated column attributes" do
+		r=RaceCar.new
+		r.gear = :first
+		r.lights = 'off'
+		r.save!
+		r.update_attributes({:gear=>:second, :lights=>'on'})
+		s=RaceCar.find r.id
+		s.gear.should == :second
+		s.lights.should == 'on'
+		s.update_attributes({:gear=>'over_drive', :lights=>'off'})
+		t=RaceCar.find s.id
+		t.gear.should == :over_drive
+		t.lights.should == 'off'
+	end
+	
+	it "should provide symbol values for enumerated column attributes from the :attributes method" do
+		r=RaceCar.new
+		r.lights = 'on'
+		r.save!
+		
+		s=RaceCar.find r.id
+		s.attributes['gear'].should == :neutral
+	end
+	
+	it "should provide normal values for non-enumerated column attributes from the :attributes method"  do
+		r=RaceCar.new
+		r.lights = 'on'
+		r.save!
+		
+		s=RaceCar.find r.id
+		s.attributes['lights'].should == 'on'
+	end
+	
+	it "should raise InvalidEnumeration when setting invalid enumertion value with :attributes= method" do
+		r=RaceCar.new
+		lambda { r.attributes = {:gear=>:yo, :lights=>'on'} }.should raise_error(EnumeratedAttribute::InvalidEnumeration)
+	end
+	
+	it "should not set init value for enumerated column attribute saved as nil" do
+		r=RaceCar.new
+		r.gear = nil
+		r.lights = 'on'
+		r.save!
+		
+		s=RaceCar.find r.id
+		s.gear.should == nil
+		s.lights.should == 'on'
+	end
+	
+	it "should not set init value for enumerated column attributes saved as value" do
+		r=RaceCar.new
+		r.gear = :second
+		r.lights = 'all'
+		r.save!
+		
+		s=RaceCar.find r.id
+		s.gear.should == :second
+		s.lights.should == 'all'
+	end
+
+	it "should save and retrieve its name" do
+		r = RaceCar.new
+		r.name= 'Green Meanie'
+		r.save!
+		
+		s = RaceCar.find r.id
+		s.should_not be_nil
+		s.name.should == 'Green Meanie'
+	end
+	
+	it "should save and retrieve symbols for enumerated column attribute" do
+		r = RaceCar.new
+		r.gear = :over_drive
+		r.save!
+		
+		s = RaceCar.find r.id
+		#s.should_not be_nil
+		s.gear.should == :over_drive
+	end
+	
+	it "should not save values for non-column enumerated attributes" do
+		r=RaceCar.new
+		r.choke = :medium
+		r.save!
+		
+		s=RaceCar.find r.id
+		s.choke.should == :none
+	end
+	
+	it "should save string and retrieve string for non-enumerated column attributes" do
+		r =RaceCar.new
+		r.lights = 'on'
+		r.save!
+		
+		s = RaceCar.find r.id
+		s.lights.should == 'on'
+		s[:lights].should == 'on'
+	end
+	
+	it "should save symbol and retrieve string for non-enumerated column attributes" do
+		r =RaceCar.new
+		r.lights = :off
+		r.save!
+		
+		s = RaceCar.find r.id
+		s.lights.should == "--- :off\n"
+		s[:lights].should == "--- :off\n"
+	end
+	
+end