validates_existence 0.4.0 → 0.5.2

data/README.markdown

@@ -4,7 +4,31 @@ This plugin library adds ActiveRecord models a way to check if a `:belongs_to` a
 This is achieved via adding a `validates_existence_of` validator to the base validations module.  
 It also supports `:allow_nil => true/false` and `:polymorphic => true` associations.
 
-### Example
+Version 0.4.0 also adds Rails 3 support  (the appropriate version is used automatically).
+Version 0.5.0 introduces a new option - `:both` and changes the default behaviour of error attaching.
+
+#### Changes in 0.5.0
+
+In verions prior to 0.5.0 the error message was attached to the field which the validation was defined on.
+For example if the validation was on `:relation_id` field, then the error was accessible via `object.errors.on(:relation_id)`.
+The new default behaviour is attaching the error on both fields: `:relation` and `:relation_id` for convenience.
+This functionality can be controlled through the `:both` option, which accepts true/false value and defaults to true.
+
+### Installation
+First install the gem:
+    sudo gem install validates_existence
+
+#### Rails 2.x
+    # environment.rb
+    config.gem "validates_existence", :source => "http://rubygems.org"
+
+#### Rails 3
+    # Gemfile
+    gem "validates_existence", ">= 0.4"
+
+### Example usage
+
+#### Rails 2.x
     class Pony < ActiveRecord::Base
       belongs_to :wizard
       belongs_to :person, :polymorphic => true
@@ -12,6 +36,8 @@ It also supports `:allow_nil => true/false` and `:polymorphic => true` associati
       validates_existence_of :wizard_id
       validates_existence_of :wizard      #works both ways
 
+      validates_existence_of :wizard, :both => false
+
       validates_existence_of :person, :allow_nil => true
     end
 
@@ -20,13 +46,25 @@ It also supports `:allow_nil => true/false` and `:polymorphic => true` associati
     pony.valid?
 
     pony.errors.on(:wizard) #=> "does not exist"
+
+#### Rails 3
+    class Unicorn < ActiveRecord::Base
+      belongs_to :wizard
+      belongs_to :person, :polymorphic => true
+
+      validates :wizard,    :existence => true
+      validates :wizard_id, :existence => true # works both way
+      validates :person,    :existence => { :allow_nil => true, :both => false }
+
+      # the old method is supported also
+      validates_existence :wizard
+    end
     
 ## I18N
 
 The default error message is `does not exist`.  
 This can be customized via Rails I18N like any other validation error message via `:existence` key.
 
-
 ### Example
 
 This would be your customized en.yaml:
@@ -45,4 +83,4 @@ This plugin is inspired by ideas from **Josh Susser**
 **Tarmo Lehtpuu** - tarmo.lehtpuu_at_perfectline_d0t_ee
 
 ## License
-Copyright 2009 by PerfectLine LLC (<http://www.perfectline.co.uk>) and is released under the MIT license.
+Copyright 2010 by PerfectLine LLC (<http://www.perfectline.co.uk>) and is released under the MIT license.

data/lib/rails2/validator.rb

@@ -1,40 +1,40 @@
-module Perfectline
-  module ValidatesExistence
-
-    def validates_existence_of(*attr_names)
-      configuration = {:message => "does not exist", :on => :save}
-      configuration.update(attr_names.extract_options!.symbolize_keys)
-
-      send(validation_method(configuration[:on] || :save), configuration) do |record|
-
-        attr_names.each do |attr|
-          association = reflect_on_association(attr.to_s.sub(/_id$/, '').to_sym)
-
-          if association.nil? || association.macro != :belongs_to
-            raise ArgumentError, "Can not validate existence on #{attribute}, not a belongs_to association."
-          end
-
-          value = record.__send__(association.primary_key_name)
-          next if value.nil? && configuration[:allow_nil]
-
-          if association.options.has_key?(:foreign_type)
-            foreign_type = record.__send__(association.options[:foreign_type])
-
-            if not foreign_type.blank?
-              association_class = foreign_type.constantize
-            else
-              record.errors.add(attr, :existence, :default => configuration[:message]) and next
-            end
-          else
-            association_class = association.klass
-          end
-
-          unless association_class.exists?(value)
-            record.errors.add(attr, :existence, :default => configuration[:message])
-          end
-        end
-      end
-    end
-
-  end
+module Perfectline
+  module ValidatesExistence
+
+    def validates_existence_of(*attribute_names)
+      options = attribute_names.extract_options!.symbolize_keys
+      options[:message] ||= :existence
+      options[:both]    = true unless options.has_key?(:both)
+
+      validates_each(attribute_names, options) do |record, attribute, value|
+        normalized  = attribute.to_s.sub(/_id$/, "").to_sym
+        association = record.class.reflect_on_association(normalized)
+
+        if association.nil? or !association.belongs_to?
+          raise ArgumentError, "Cannot validate existence on #{normalized}, not a :belongs_to association"
+        end
+
+        target_class = nil
+
+        # dealing with polymorphic belongs_to
+        if association.options.has_key?(:foreign_type)
+          foreign_type = record.__send__(association.options.fetch(:foreign_type))
+          target_class = foreign_type.constantize unless foreign_type.nil?
+        else
+          target_class = association.klass
+        end
+
+        if target_class.nil? or !target_class.exists?(value)
+          record.errors.add(attribute, options[:message], :default => "does not exist")
+
+          # add the error on both :relation and :relation_id
+          if options[:both]
+            normalized = attribute.to_s.ends_with?("_id") ? normalized : "#{attribute}_id"
+            record.errors.add(normalized, options[:message], :default => "does not exist")
+          end
+        end
+      end
+    end
+
+  end
 end

data/lib/rails3/validator.rb

@@ -1,54 +1,55 @@
-module Perfectline
-  module ValidatesExistence
-
-    module InstanceMethods
-      class ExistenceValidator < ActiveModel::EachValidator
-
-        def initialize(options)
-          # set the default message if its unspecified
-          options[:message] ||= :existence
-          super(options)
-        end
-
-        def validate_each(record, attribute, value)
-          normalized = attribute.to_s.sub(/_id$/, "").to_sym
-          association = record.class.reflect_on_association(normalized)
-
-          if association.nil? or !association.belongs_to?
-            raise ArgumentError, "Cannot validate existence on #{normalized}, not a :belongs_to association"
-          end
-
-          target_class = nil
-
-          # dealing with polymorphic belongs_to
-          if association.options.has_key?(:foreign_type)
-            foreign_type = record.__send__(association.options.fetch(:foreign_type))
-            target_class = foreign_type.constantize unless foreign_type.nil?
-          else
-            target_class = association.klass
-          end
-
-          if target_class.nil? or !target_class.exists?(value)
-            record.errors.add(attribute, options[:message], :default => "does not exist")
-
-            # add the error on both :relation and :relation_id
-            if options[:both]
-              normalized = attribute.to_s.ends_with?("_id") ? normalized : "#{attribute}_id"
-              record.errors.add(normalized, options[:message], :default => "does not exist")
-            end
-          end
-        end
-
-      end
-    end
-
-    module ClassMethods
-
-      def validates_existence_of(*attr_names)
-        validates_with ExistenceValidator, _merge_attributes(attr_names)
-      end
-
-    end
-
-  end
+module Perfectline
+  module ValidatesExistence
+
+    module InstanceMethods
+      class ExistenceValidator < ActiveModel::EachValidator
+
+        def initialize(options)
+          # set the default message if its unspecified
+          options[:message] ||= :existence
+          options[:both]    ||= true
+          super(options)
+        end
+
+        def validate_each(record, attribute, value)
+          normalized = attribute.to_s.sub(/_id$/, "").to_sym
+          association = record.class.reflect_on_association(normalized)
+
+          if association.nil? or !association.belongs_to?
+            raise ArgumentError, "Cannot validate existence on #{normalized}, not a :belongs_to association"
+          end
+
+          target_class = nil
+
+          # dealing with polymorphic belongs_to
+          if association.options.has_key?(:foreign_type)
+            foreign_type = record.__send__(association.options.fetch(:foreign_type))
+            target_class = foreign_type.constantize unless foreign_type.nil?
+          else
+            target_class = association.klass
+          end
+
+          if target_class.nil? or !target_class.exists?(value)
+            record.errors.add(attribute, options[:message], :default => "does not exist")
+
+            # add the error on both :relation and :relation_id
+            if options[:both]
+              normalized = attribute.to_s.ends_with?("_id") ? normalized : "#{attribute}_id"
+              record.errors.add(normalized, options[:message], :default => "does not exist")
+            end
+          end
+        end
+
+      end
+    end
+
+    module ClassMethods
+
+      def validates_existence_of(*attr_names)
+        validates_with ExistenceValidator, _merge_attributes(attr_names)
+      end
+
+    end
+
+  end
 end

data/lib/validates_existence.rb

@@ -1,11 +1,11 @@
-if Rails::VERSION::MAJOR >= 3
-  require "active_model"
-  require "rails3/validator"
-
-  ActiveModel::Validations.__send__(:include, Perfectline::ValidatesExistence::InstanceMethods)
-  ActiveModel::Validations.__send__(:extend,  Perfectline::ValidatesExistence::ClassMethods)
-else
-  require "rails2/validator"
-  
-  ActiveRecord::Base.__send__(:extend, Perfectline::ValidatesExistence)
+if Rails::VERSION::MAJOR >= 3
+  require "active_model"
+  require "rails3/validator"
+
+  ActiveModel::Validations.__send__(:include, Perfectline::ValidatesExistence::InstanceMethods)
+  ActiveModel::Validations.__send__(:extend,  Perfectline::ValidatesExistence::ClassMethods)
+else
+  require "rails2/validator"
+  
+  ActiveRecord::Base.__send__(:extend, Perfectline::ValidatesExistence)
 end

data/test/models/user.rb

@@ -2,6 +2,6 @@ class User < ActiveRecord::Base
 
   belongs_to :name
 
-  validates_existence_of :name
+  validates_existence_of :name, :both => false
 
 end

data/test/models/user_with_both.rb

@@ -0,0 +1,7 @@
+class UserWithBoth < ActiveRecord::Base
+  self.table_name = "users"
+
+  belongs_to :name
+
+  validates_existence_of :name, :both => false
+end

data/test/models/user_with_has_many.rb

@@ -0,0 +1,7 @@
+class UserWithHasMany < ActiveRecord::Base
+  self.table_name = "users"
+
+  has_many :names
+
+  validates_existence_of :names
+end

data/test/test_helper.rb

@@ -9,7 +9,7 @@ require 'active_record/base'
 
 ActiveRecord::Migration.verbose = false
 ActiveRecord::Base.establish_connection(
-        "adapter" => "sqlite3",
+        "adapter" =>  "sqlite3",
         "database" => ":memory:"
 )
 
@@ -19,4 +19,6 @@ autoload :Name,                 File.join(File.dirname(__FILE__), 'models', 'nam
 autoload :User,                 File.join(File.dirname(__FILE__), 'models', 'user.rb')
 autoload :UserWithAllowNil,     File.join(File.dirname(__FILE__), 'models', 'user_with_allow_nil.rb')
 autoload :UserWithPoly,         File.join(File.dirname(__FILE__), 'models', 'user_with_poly.rb')
-autoload :UserWithPolyAllowNil, File.join(File.dirname(__FILE__), 'models', 'user_with_poly_allow_nil.rb')
+autoload :UserWithPolyAllowNil, File.join(File.dirname(__FILE__), 'models', 'user_with_poly_allow_nil.rb')
+autoload :UserWithHasMany,      File.join(File.dirname(__FILE__), 'models', 'user_with_has_many.rb')
+autoload :UserWithBoth,         File.join(File.dirname(__FILE__), 'models', 'user_with_both.rb')

data/test/validates_existence_test.rb

@@ -23,7 +23,10 @@ class TestValidatesExistence < Test::Unit::TestCase
   end
   
   def test_save_with_no_relation
-    assert_equal User.new.save, false
+    user = User.new
+    assert_equal    user.save, false
+    assert_not_nil  user.errors.on(:name)
+    assert_not_nil  user.errors.on(:name)
   end
 
   def test_save_with_relation
@@ -52,6 +55,19 @@ class TestValidatesExistence < Test::Unit::TestCase
     assert_equal UserWithPolyAllowNil.new.save, true
   end
 
+  def test_argument_error
+    assert_raise ArgumentError do
+      UserWithHasMany.new.save
+    end
+  end
+
+  def test_errors_on_one_field
+    user = UserWithBoth.new
+    user.save
+    assert_not_nil  user.errors.on(:name)
+    assert_nil      user.errors.on(:name_id)
+  end
+
 end
 
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 4
-  - 0
-  version: 0.4.0
+  - 5
+  - 2
+  version: 0.5.2
 platform: ruby
 authors: 
 - Tanel Suurhans
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-14 00:00:00 +03:00
+date: 2010-04-15 00:00:00 +03:00
 default_executable: 
 dependencies: []
 
@@ -70,6 +70,8 @@ test_files:
 - test/models/name.rb
 - test/models/user.rb
 - test/models/user_with_allow_nil.rb
+- test/models/user_with_both.rb
+- test/models/user_with_has_many.rb
 - test/models/user_with_poly.rb
 - test/models/user_with_poly_allow_nil.rb
 - test/test_helper.rb