validates_existence 0.8.0 → 0.9.2

data/lib/validates_existence.rb

@@ -1,7 +1,86 @@
-if Rails::VERSION::MAJOR >= 3
-  require 'rails3'
-  ActiveRecord::Base.send(:include, Perfectline::ValidatesExistence::Rails3)
-else
-  require 'rails2'
-  ActiveRecord::Base.send(:extend,  Perfectline::ValidatesExistence::Rails2)
+require "active_record"
+
+module Perfectline
+  module ValidatesExistence
+    module Validator
+      class ExistenceValidator < ActiveModel::EachValidator
+
+        def initialize(options)
+          # set the default message if its unspecified
+          options[:message] ||= :existence
+          options[:both]    = true unless options.key?(:both)
+          options[:allow_new] = false unless options.key?(:allow_new)
+          super(options)
+        end
+
+        def validate(record)
+          attributes.each do |attribute|
+            value = record.read_attribute_for_validation(attribute)
+            target_id = if !attribute.match(/_id$/) && options[:allow_nil]
+                association = record.class.reflect_on_association(attribute)
+                association.respond_to?(:foreign_key)  ? record[association.foreign_key] : record[association.association_foreign_key]
+              else
+                value
+              end
+            next if (target_id.nil? && value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+            validate_each(record, attribute, value)
+          end
+        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? || !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[:polymorphic]
+            foreign_type = record.send(association.options[:foreign_type] || association.foreign_type)
+            target_class = foreign_type.constantize unless foreign_type.nil?
+          else
+            target_class = association.klass
+          end
+
+          if value.nil? || target_class.nil? || !exists?(target_class, value)
+            errors = [attribute]
+
+            # add the error on both :relation and :relation_id
+            if options[:both]
+              if ActiveRecord::VERSION::MAJOR > 3 || (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR >= 1)
+                foreign_key = association.foreign_key
+              else
+                foreign_key = association.primary_key_name
+              end
+
+              errors << (attribute.to_s.ends_with?("_id") ? normalized : foreign_key)
+            end
+
+            messages = [:"#{record.class.i18n_scope}.errors.messages.existence", "does not exist"]
+
+            errors.each do |error|
+              record.errors.add(error, options[:message], :message => messages)
+            end
+          end
+        end
+
+        def exists?(target_class, value)
+          (options[:allow_new] && value.new_record?) || target_class.exists?(value)
+        end
+      end
+    end
+
+    module ClassMethods
+      def validates_existence_of(*attr_names)
+        validates_with ActiveRecord::Base::ExistenceValidator, _merge_attributes(attr_names)
+      end
+    end
+
+  end
 end
+
+ActiveRecord::Base.send(:include, Perfectline::ValidatesExistence::Validator)
+ActiveRecord::Base.send(:extend, Perfectline::ValidatesExistence::ClassMethods)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: validates_existence
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,8 +10,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-08 00:00:00.000000000 Z
-dependencies: []
+date: 2013-09-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A library for validating model association existence.
 email:
 - tanel.suurhans@perfectline.ee
@@ -23,8 +39,6 @@ extra_rdoc_files:
 files:
 - README.markdown
 - install.rb
-- lib/rails2.rb
-- lib/rails3.rb
 - lib/validates_existence.rb
 - rails/init.rb
 homepage: http://github.com/perfectline/validates_existence/tree/master
@@ -47,8 +61,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Validates Rails model belongs_to association existence.
 test_files: []

data/lib/rails2.rb

@@ -1,52 +0,0 @@
-module Perfectline
-  module ValidatesExistence
-
-    module Rails2
-      def validates_existence_of(*attribute_names)
-        options = attribute_names.extract_options!.symbolize_keys
-        options[:message] ||= :existence
-        options[:both]    = true unless options.key?(:both)
-        options[:allow_new] = false unless options.key?(:allow_new)
-
-        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 options[:allow_new]
-            exists = value.new_record? or target_class.exists?(value)
-          else
-            exists = target_class.exists?(value)
-          end
-
-          if target_class.nil? or !exists
-            errors = [attribute]
-
-            # add the error on both :relation and :relation_id
-            if options[:both]
-              errors.push(attribute.to_s.ends_with?("_id") ? normalized : association.primary_key_name)
-            end
-
-            errors.each do |error|
-              record.errors.add(error, options[:message], :default => "does not exist")
-            end
-          end
-        end
-      end
-    end
-  end
-end
-

data/lib/rails3.rb

@@ -1,74 +0,0 @@
-require 'active_support/concern'
-require 'active_model'
-
-module Perfectline
-  module ValidatesExistence
-
-    module Rails3
-      extend ActiveSupport::Concern
-
-      class ExistenceValidator < ActiveModel::EachValidator
-
-        def initialize(options)
-          # set the default message if its unspecified
-          options[:message] ||= :existence
-          options[:both]    = true unless options.key?(:both)
-          options[:allow_new] = false unless options.key?(:allow_new)
-          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? || !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[:polymorphic]
-            foreign_type = record.send(association.options[:foreign_type] || association.foreign_type)
-            target_class = foreign_type.constantize unless foreign_type.nil?
-          else
-            target_class = association.klass
-          end
-
-          if value.nil? || target_class.nil? || !exists?(target_class, value)
-            errors = [attribute]
-
-            # add the error on both :relation and :relation_id
-            if options[:both]
-              if Rails::VERSION::MINOR >= 1
-                foreign_key = association.foreign_key
-              else
-                foreign_key = association.primary_key_name
-              end
-
-              errors << (attribute.to_s.ends_with?("_id") ? normalized : foreign_key)
-            end
-
-            messages = [:"#{record.class.i18n_scope}.errors.messages.existence", "does not exist"]
-
-            errors.each do |error|
-              record.errors.add(error, options[:message], :message => messages)
-            end
-          end
-        end
-
-        def exists?(target_class, value)
-          (options[:allow_new] && value.new_record?) || target_class.exists?(value)
-        end
-      end
-
-      module ClassMethods
-        def validates_existence_of(*attr_names)
-          validates_with ExistenceValidator, _merge_attributes(attr_names)
-        end
-      end
-
-    end
-  end
-end
-