enumerate_by 0.4.2 → 0.4.3

data/CHANGELOG.rdoc

@@ -1,5 +1,12 @@
 == master
 
+== 0.4.3 / 2009-06-14
+
+* Add support for looking up enumerators by their symbol equivalent
+* Fix incompatibility with Ruby 1.9
+* Fix equality / xml serialization not working for non-string enumerators
+* Improve compatibility with the stable branch of Rails 2.3 [Michael Schuerig]
+
 == 0.4.2 / 2009-05-03
 
 * Fix bootstrapping without ids not working on update for certain database adapters

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/contrib/sshpublisher'
 
 spec = Gem::Specification.new do |s|
   s.name              = 'enumerate_by'
-  s.version           = '0.4.2'
+  s.version           = '0.4.3'
   s.platform          = Gem::Platform::RUBY
   s.summary           = 'Adds support for declaring an ActiveRecord class as an enumeration'
   s.description       = s.summary
@@ -53,7 +53,14 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   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
+end
+
 Rake::GemPackageTask.new(spec) do |p|
   p.gem_spec = spec
   p.need_tar = true

data/lib/enumerate_by.rb

@@ -57,8 +57,7 @@ module EnumerateBy
     # == Associations
     # 
     # When using enumerations together with +belongs_to+ associations, the
-    # enumerator value can be used as a shortcut for assigning the
-    # association.
+    # enumerator value can be used as a shortcut for assigning the association.
     # 
     # In addition, the enumerator value is automatically used during
     # serialization (xml and json) of the associated record instead of the
@@ -126,7 +125,7 @@ module EnumerateBy
     #   Color.find_by_enumerator('red')     # => #<Color id: 1, name: "red">
     #   Color.find_by_enumerator('invalid') # => nil
     def find_by_enumerator(enumerator)
-      first(:conditions => {enumerator_attribute => enumerator})
+      first(:conditions => {enumerator_attribute => typecast_enumerator(enumerator)})
     end
     
     # Finds the record that is associated with the given enumerator.  If no
@@ -140,7 +139,7 @@ module EnumerateBy
     # 
     # To avoid raising an exception on invalid enumerators, use +find_by_enumerator+.
     def find_by_enumerator!(enumerator)
-      find_by_enumerator(enumerator) || raise(ActiveRecord::RecordNotFound, "Couldn't find #{name} with #{enumerator_attribute} #{enumerator.inspect}")
+      find_by_enumerator(enumerator) || raise(ActiveRecord::RecordNotFound, "Couldn't find #{name} with #{enumerator_attribute} #{typecast_enumerator(enumerator).inspect}")
     end
     alias_method :[], :find_by_enumerator!
     
@@ -148,10 +147,10 @@ module EnumerateBy
     # 
     # For example,
     # 
-    #   Color.find_all_by_enumerator('red', 'green')  # => [#<Color id: 1, name: "red">, #<Color id: 1, name: "green">]
-    #   Color.find_all_by_enumerator('invalid')       # => []
+    #   Color.find_all_by_enumerator(['red', 'green'])  # => [#<Color id: 1, name: "red">, #<Color id: 1, name: "green">]
+    #   Color.find_all_by_enumerator('invalid')         # => []
     def find_all_by_enumerator(enumerators)
-      all(:conditions => {enumerator_attribute => enumerators})
+      all(:conditions => {enumerator_attribute => typecast_enumerator(enumerators)})
     end
     
     # Finds records with the given enumerators.  If no record is found for a
@@ -160,13 +159,14 @@ module EnumerateBy
     # 
     # For Example,
     # 
-    #   Color.find_all_by_enumerator!('red', 'green')   # => [#<Color id: 1, name: "red">, #<Color id: 1, name: "green">]
+    #   Color.find_all_by_enumerator!(['red', 'green']) # => [#<Color id: 1, name: "red">, #<Color id: 1, name: "green">]
     #   Color.find_all_by_enumerator!('invalid')        # => ActiveRecord::RecordNotFound: Couldn't find Color with name(s) "invalid"
     # 
     # To avoid raising an exception on invalid enumerators, use +find_all_by_enumerator+.
     def find_all_by_enumerator!(enumerators)
+      enumerators = [enumerators].flatten
       records = find_all_by_enumerator(enumerators)
-      missing = [enumerators].flatten - records.map(&:enumerator)
+      missing = enumerators - records.map(&:enumerator)
       missing.empty? ? records : raise(ActiveRecord::RecordNotFound, "Couldn't find #{name} with #{enumerator_attribute}(s) #{missing.map(&:inspect).to_sentence}")
     end
     
@@ -178,9 +178,9 @@ module EnumerateBy
     [:find_by_sql, :exists?, :calculate].each do |method|
       define_method(method) do |*args|
         if EnumerateBy.perform_caching && perform_enumerator_caching
-          enumerator_cache_store.fetch([method] + args) { super }
+          enumerator_cache_store.fetch([method] + args) { super(*args) }
         else
-          super
+          super(*args)
         end
       end
     end
@@ -195,6 +195,20 @@ module EnumerateBy
     ensure
       self.perform_enumerator_caching = old
     end
+    
+    private
+      # Typecasts the given enumerator to its actual value stored in the
+      # database.  This will only convert symbols to strings.  All other values
+      # will remain in the same type.
+      def typecast_enumerator(enumerator)
+        if enumerator.is_a?(Array)
+          enumerator.flatten!
+          enumerator.map! {|value| typecast_enumerator(value)}
+          enumerator
+        else
+          enumerator.is_a?(Symbol) ? enumerator.to_s : enumerator
+        end
+      end
   end
   
   module Bootstrapped
@@ -295,8 +309,8 @@ module EnumerateBy
     # * Dirty attributes
     # 
     # Also note that records are created directly without creating instances
-    # of the model.  As a result, all of the attributes for the record must
-    # be specified.
+    # of the model.  As a result, all of the attributes for the record must be
+    # specified.
     # 
     # This produces a significant performance increase when bootstrapping more
     # than several hundred records.
@@ -351,7 +365,7 @@ module EnumerateBy
     # a String, then it is compared against the enumerator.  Otherwise,
     # ActiveRecord's default equality comparator is used.
     def ==(arg)
-      arg.is_a?(String) ? self == self.class.find_by_enumerator!(arg) : super
+      arg.nil? || arg.is_a?(self.class) ? super : self == self.class.find_by_enumerator!(arg)
     end
     
     # Determines whether this enumeration is in the given list.

data/lib/enumerate_by/extensions/base_conditions.rb

@@ -66,15 +66,15 @@ module EnumerateBy
       end
       
       # Sanitizes a hash of attribute/value pairs into SQL conditions for a WHERE clause.
-      def sanitize_sql_hash_for_conditions_with_enumerations(attrs)
+      def sanitize_sql_hash_for_conditions_with_enumerations(attrs, *args)
         replace_enumerations_in_hash(attrs)
-        sanitize_sql_hash_for_conditions_without_enumerations(attrs)
+        sanitize_sql_hash_for_conditions_without_enumerations(attrs, *args)
       end
       
       # Sanitizes a hash of attribute/value pairs into SQL conditions for a SET clause.
-      def sanitize_sql_hash_for_assignment_with_enumerations(attrs)
+      def sanitize_sql_hash_for_assignment_with_enumerations(attrs, *args)
         replace_enumerations_in_hash(attrs, false)
-        sanitize_sql_hash_for_assignment_without_enumerations(attrs)
+        sanitize_sql_hash_for_assignment_without_enumerations(attrs, *args)
       end
       
       # Make sure dynamic finders don't fail since it won't find the association
@@ -106,7 +106,7 @@ module EnumerateBy
             klass = reflection.klass
             attribute = reflection.primary_key_name
             id = if allow_multiple && enumerator.is_a?(Array)
-              enumerator.map {|enumerator| klass.find_by_enumerator!(enumerator).id}
+              klass.find_all_by_enumerator!(enumerator).map(&:id)
             else
               klass.find_by_enumerator!(enumerator).id
             end

data/lib/enumerate_by/extensions/xml_serializer.rb

@@ -14,7 +14,21 @@ module EnumerateBy
         protected
           # Enumerator types are always strings
           def compute_type_with_enumerations
-            enumeration_association? ? :string : compute_type_without_enumerations
+            if enumeration_association?
+              klass = @record.class.reflections[name.to_sym].klass
+              type = klass.columns_hash[klass.enumerator_attribute.to_s].type
+              
+              case type
+                when :text
+                  :string
+                when :time
+                  :datetime
+                else
+                  type
+              end
+            else
+              compute_type_without_enumerations
+            end
           end
           
           # Gets the real value representing the enumerator

data/test/app_root/app/models/car_part.rb

@@ -0,0 +1,3 @@
+class CarPart < ActiveRecord::Base
+  enumerate_by :number
+end

data/test/app_root/app/models/order.rb

@@ -0,0 +1,3 @@
+class Order < ActiveRecord::Base
+  belongs_to :car_part
+end

data/test/app_root/db/migrate/003_create_car_parts.rb

@@ -0,0 +1,12 @@
+class CreateCarParts < ActiveRecord::Migration
+  def self.up
+    create_table :car_parts do |t|
+      t.string :name
+      t.integer :number
+    end
+  end
+  
+  def self.down
+    drop_table :car_parts
+  end
+end

data/test/app_root/db/migrate/004_create_orders.rb

@@ -0,0 +1,12 @@
+class CreateOrders < ActiveRecord::Migration
+  def self.up
+    create_table :orders do |t|
+      t.string :state
+      t.references :car_part
+    end
+  end
+  
+  def self.down
+    drop_table :orders
+  end
+end

data/test/factory.rb

@@ -40,9 +40,22 @@ module Factory
     )
   end
   
+  build CarPart do |attributes|
+    attributes.reverse_merge!(
+      :number => 123321
+    )
+  end
+  
   build Color do |attributes|
     attributes.reverse_merge!(
       :name => 'red'
     )
   end
+  
+  build Order do |attributes|
+    attributes[:car_part] = create_car_part unless attributes.include?(:car_part)
+    attributes.reverse_merge!(
+      :state => 'pending'
+    )
+  end
 end

data/test/unit/assocations_test.rb

@@ -23,7 +23,12 @@ class ModelWithBelongsToAssociationTest < ActiveRecord::TestCase
   end
   
   def test_should_use_nil_if_enumeration_does_not_exist
-    @car.color = 'blue'
+    assert_nothing_raised { @car.color = 'blue' }
+    assert_nil @car.color
+  end
+  
+  def test_should_allow_nil
+    assert_nothing_raised { @car.color = nil }
     assert_nil @car.color
   end
   

data/test/unit/base_conditions_test.rb

@@ -12,17 +12,49 @@ class EnumerationWithFinderConditionsTest < ActiveRecord::TestCase
     assert_equal @red_car, Car.find_by_color('red')
   end
   
+  def test_should_raise_exception_for_invalid_enumeration_in_dynamic_finders
+    assert_raise(ActiveRecord::RecordNotFound) { Car.find_by_color('invalid') }
+  end
+  
+  def test_should_still_allow_non_enumeration_in_dynamic_finders
+    assert_equal @red_car, Car.find_by_id(@red_car.id)
+  end
+  
   def test_should_replace_multiple_enumerations_in_dynamic_finders
     assert_equal [@red_car, @blue_car], Car.find_all_by_color(%w(red blue))
   end
   
+  def test_should_raise_exception_for_any_invalid_enumeration_in_dynamic_finders
+    assert_raise(ActiveRecord::RecordNotFound) { Car.find_all_by_color(%w(red invalid)) }
+  end
+  
+  def test_should_still_allow_multiple_non_enumerations_in_dynamic_finders
+    assert_equal [@red_car, @blue_car], Car.find_all_by_id([@red_car.id, @blue_car.id])
+  end
+  
   def test_should_replace_enumerations_in_find_conditions
     assert_equal @red_car, Car.first(:conditions => {:color => 'red'})
   end
   
+  def test_should_raise_exception_for_invalid_enumeration_in_find_conditions
+    assert_raise(ActiveRecord::RecordNotFound) { Car.first(:conditions => {:color => 'invalid'}) }
+  end
+  
+  def test_should_still_allow_non_enumeration_in_find_conditions
+    assert_equal @red_car, Car.first(:conditions => {:id => @red_car.id})
+  end
+  
   def test_should_replace_multiple_enumerations_in_find_conditions
     assert_equal [@red_car, @blue_car], Car.all(:conditions => {:color => %w(red blue)})
   end
+  
+  def test_should_raise_exception_for_any_invalid_enumeration_in_find_conditions
+    assert_raise(ActiveRecord::RecordNotFound) { Car.all(:conditions => {:color => %w(red invalid)}) }
+  end
+  
+  def test_should_still_allow_multiple_non_enumerations_in_find_conditions
+    assert_equal [@red_car, @blue_car], Car.all(:conditions => {:id => [@red_car.id, @blue_car.id]})
+  end
 end
 
 class EnumerationWithFinderUpdatesTest < ActiveRecord::TestCase
@@ -38,6 +70,16 @@ class EnumerationWithFinderUpdatesTest < ActiveRecord::TestCase
     assert_equal @blue, @red_car.color
   end
   
+  def test_should_raise_exception_for_invalid_enumeration_in_update_conditions
+    assert_raise(ActiveRecord::RecordNotFound) { Car.update_all({:color => 'invalid'}, :name => 'Ford Mustang') }
+  end
+  
+  def test_should_still_allow_non_enumeration_in_update_conditions
+    Car.update_all({:color => 'blue'}, :id => @red_car.id)
+    @red_car.reload
+    assert_equal @blue, @red_car.color
+  end
+  
   def test_should_not_replace_multiple_enumerations_in_update_conditions
     Car.update_all({:color => %w(red blue)}, :name => 'Ford Mustang')
     @red_car.reload

data/test/unit/enumerate_by_test.rb

@@ -102,7 +102,8 @@ class EnumerationWithRecordsTest < ActiveRecord::TestCase
   end
   
   def test_should_raise_exception_for_invalid_index
-    assert_raise(ActiveRecord::RecordNotFound) {Color['white']}
+    exception = assert_raise(ActiveRecord::RecordNotFound) {Color['white']}
+    assert_equal "Couldn't find Color with name \"white\"", exception.message
   end
   
   def test_should_allow_finding_all_by_enumerator
@@ -118,11 +119,63 @@ class EnumerationWithRecordsTest < ActiveRecord::TestCase
   end
   
   def test_should_raise_exception_find_finding_all_by_unknown_enumerator!
-    assert_raise(ActiveRecord::RecordNotFound) { Color.find_all_by_enumerator!('invalid') }
+    exception = assert_raise(ActiveRecord::RecordNotFound) { Color.find_all_by_enumerator!('invalid') }
+    assert_equal "Couldn't find Color with name(s) \"invalid\"", exception.message
   end
   
   def test_should_raise_exception_if_only_some_found_when_finding_all_by_enumerator!
-    assert_raise(ActiveRecord::RecordNotFound) { Color.find_all_by_enumerator!(['red', 'invalid']) }
+    exception = assert_raise(ActiveRecord::RecordNotFound) { Color.find_all_by_enumerator!(['red', 'invalid']) }
+    assert_equal "Couldn't find Color with name(s) \"invalid\"", exception.message
+  end
+end
+
+class EnumerationWithSymbolReferencesTest < ActiveRecord::TestCase
+  def setup
+    @red = create_color(:name => 'red')
+    @green = create_color(:name => 'green')
+  end
+  
+  def test_should_index_by_enumerator
+    assert_equal @red, Color[:red]
+  end
+  
+  def test_should_allow_finding_by_enumerator
+    assert_equal @red, Color.find_by_enumerator(:red)
+  end
+  
+  def test_should_allow_finding_by_enumerator_with_nil
+    assert_nil Color.find_by_enumerator(nil)
+  end
+  
+  def test_should_find_nothing_if_finding_by_unknown_enumerator
+    assert_nil Color.find_by_enumerator(:invalid)
+  end
+  
+  def test_should_raise_exception_for_invalid_index
+    exception = assert_raise(ActiveRecord::RecordNotFound) {Color[:white]}
+    assert_equal "Couldn't find Color with name \"white\"", exception.message
+  end
+  
+  def test_should_allow_finding_all_by_enumerator
+    assert_equal [@red, @green], Color.find_all_by_enumerator([:red, :green])
+  end
+  
+  def test_should_allow_finding_all_by_enumerator_with_nil
+    assert_equal [], Color.find_all_by_enumerator(nil)
+  end
+  
+  def test_should_find_nothing_if_finding_all_by_unknown_enumerator
+    assert_equal [], Color.find_all_by_enumerator(:invalid)
+  end
+  
+  def test_should_raise_exception_find_finding_all_by_unknown_enumerator!
+    exception = assert_raise(ActiveRecord::RecordNotFound) { Color.find_all_by_enumerator!(:invalid) }
+    assert_equal "Couldn't find Color with name(s) \"invalid\"", exception.message
+  end
+  
+  def test_should_raise_exception_if_only_some_found_when_finding_all_by_enumerator!
+    exception = assert_raise(ActiveRecord::RecordNotFound) { Color.find_all_by_enumerator!([:red, :invalid]) }
+    assert_equal "Couldn't find Color with name(s) \"invalid\"", exception.message
   end
 end
 
@@ -141,6 +194,10 @@ class EnumerationAfterBeingCreatedTest < ActiveRecord::TestCase
     assert @red == 'red'
   end
   
+  def test_should_allow_equality_with_symbol_enumerator
+    assert @red == :red
+  end
+  
   def test_should_allow_equality_with_record
     assert @red == @red
   end
@@ -149,6 +206,10 @@ class EnumerationAfterBeingCreatedTest < ActiveRecord::TestCase
     assert 'red' == @red
   end
   
+  def test_should_allow_equality_with_nil
+    assert @red != nil
+  end
+  
   def test_should_raise_exception_on_quality_with_invalid_enumerator
     assert_raise(ActiveRecord::RecordNotFound) {@red == 'invalid'}
   end
@@ -157,6 +218,10 @@ class EnumerationAfterBeingCreatedTest < ActiveRecord::TestCase
     assert @red.in?('red')
   end
   
+  def test_should_be_found_in_a_list_of_valid_symbol_names
+    assert @red.in?(:red)
+  end
+  
   def test_should_not_be_found_in_a_list_of_invalid_names
     assert !@red.in?('blue', 'green')
   end
@@ -167,6 +232,47 @@ class EnumerationAfterBeingCreatedTest < ActiveRecord::TestCase
   end
 end
 
+class EnumerationWithNumericEnumeratorAttributeTest < ActiveRecord::TestCase
+  def setup
+    @engine = create_car_part(:name => 'engine', :number => 111)
+    @radiator = create_car_part(:name => 'radiator', :number => 222)
+    @transmission = create_car_part(:name => 'transmission', :number => 333)
+  end
+  
+  def test_should_have_an_enumerator
+    assert_equal 111, @engine.enumerator
+  end
+  
+  def test_should_allow_equality_with_enumerator
+    assert @engine == 111
+  end
+  
+  def test_should_allow_equality_with_record
+    assert @engine == @engine
+  end
+  
+  def test_should_allow_equality_with_strings
+    assert '111' == @engine
+  end
+  
+  def test_should_raise_exception_on_quality_with_invalid_enumerator
+    assert_raise(ActiveRecord::RecordNotFound) {@engine == 123}
+  end
+  
+  def test_should_be_found_in_a_list_of_valid_names
+    assert @engine.in?(111)
+  end
+  
+  def test_should_not_be_found_in_a_list_of_invalid_names
+    assert !@engine.in?(222, 333)
+  end
+  
+  def test_should_stringify_enumerator
+    assert_equal '111', @engine.to_s
+    assert_equal '111', @engine.to_str
+  end
+end
+
 class EnumerationWithCachingTest < ActiveRecord::TestCase
   def setup
     @red = create_color(:name => 'red')

data/test/unit/xml_serializer_test.rb

@@ -69,3 +69,23 @@ class XmlSerializerTest < ActiveRecord::TestCase
     assert_equal expected, @car.to_xml
   end
 end
+
+class XmlSerializerWithNumericEnumeratorAttributeTest < ActiveRecord::TestCase
+  def setup
+    @engine = create_car_part(:name => 'engine', :number => 123321)
+    @order = create_order(:state => 'pending', :car_part => @engine)
+  end
+  
+  def test_should_be_able_to_convert_to_xml
+    expected = <<-eos
+<?xml version="1.0" encoding="UTF-8"?>
+<order>
+  <car-part type="integer">123321</car-part>
+  <id type="integer">#{@order.id}</id>
+  <state>pending</state>
+</order>
+    eos
+    
+    assert_equal expected, @order.to_xml
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: enumerate_by
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors: 
 - Aaron Pfeifer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-03 00:00:00 -04:00
+date: 2009-06-14 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -40,12 +40,16 @@ files:
 - test/app_root
 - test/app_root/app
 - test/app_root/app/models
+- test/app_root/app/models/order.rb
 - test/app_root/app/models/color.rb
 - test/app_root/app/models/car.rb
+- test/app_root/app/models/car_part.rb
 - test/app_root/db
 - test/app_root/db/migrate
+- test/app_root/db/migrate/003_create_car_parts.rb
 - test/app_root/db/migrate/001_create_colors.rb
 - test/app_root/db/migrate/002_create_cars.rb
+- test/app_root/db/migrate/004_create_orders.rb
 - test/test_helper.rb
 - CHANGELOG.rdoc
 - init.rb