validates_existence 0.3.2 → 0.4.0

data/lib/rails2/validator.rb

@@ -0,0 +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
+end

data/lib/rails3/validator.rb

@@ -0,0 +1,54 @@
+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
+end

data/lib/validates_existence.rb

@@ -1,52 +1,11 @@
-module Perfectline
-  module Validations
-    module ValidatesExistence
-
-      def self.included(base)
-        base.send(:extend, ClassMethods)
-      end
-
-      module ClassMethods
-
-        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|
-              attribute = attr.to_s.sub(/_id$/, '').to_sym
-              association = reflect_on_association(attribute)
-
-              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, 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
-    end
-  end
-end
-
-ActiveRecord::Base.send(:include, Perfectline::Validations::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/name.rb

@@ -0,0 +1,3 @@
+class Name < ActiveRecord::Base
+
+end

data/test/models/user.rb

@@ -0,0 +1,7 @@
+class User < ActiveRecord::Base
+
+  belongs_to :name
+
+  validates_existence_of :name
+
+end

data/test/models/user_with_allow_nil.rb

@@ -0,0 +1,9 @@
+class UserWithAllowNil < ActiveRecord::Base
+
+  self.table_name = "users"
+
+  belongs_to :name
+
+  validates_existence_of :name, :allow_nil => true
+
+end

data/test/models/user_with_poly.rb

@@ -0,0 +1,9 @@
+class UserWithPoly < ActiveRecord::Base
+
+  self.table_name = "users"
+
+  belongs_to :relation, :polymorphic => true
+
+  validates_existence_of :relation
+
+end

data/test/models/user_with_poly_allow_nil.rb

@@ -0,0 +1,9 @@
+class UserWithPolyAllowNil < ActiveRecord::Base
+
+  self.table_name = "users"
+
+  belongs_to :relation, :polymorphic => true
+
+  validates_existence_of :relation, :allow_nil => true
+
+end

data/test/test_helper.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+
+gem 'activerecord', '~> 2'
+
+require 'sqlite3'
+require 'test/unit'
+require 'active_record'
+require 'active_record/base'
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.establish_connection(
+        "adapter" => "sqlite3",
+        "database" => ":memory:"
+)
+
+require File.join(File.dirname(__FILE__), '..', 'rails', 'init.rb')
+
+autoload :Name,                 File.join(File.dirname(__FILE__), 'models', 'name.rb')
+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')

data/test/validates_existence_test.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class TestValidatesExistence < Test::Unit::TestCase
+
+  def setup
+    ActiveRecord::Schema.define(:version => 1) do
+
+      create_table :names, :force => true do |t|
+        t.column :name, :string
+      end
+
+      create_table :users, :force => true do |t|
+        t.references :name
+        t.references :relation, :polymorphic => true
+      end
+
+    end
+  end
+
+  def teardown
+    ActiveRecord::Base.connection.drop_table(:users)
+    ActiveRecord::Base.connection.drop_table(:names)
+  end
+  
+  def test_save_with_no_relation
+    assert_equal User.new.save, false
+  end
+
+  def test_save_with_relation
+    name = Name.create(:name => "foo")
+    assert_equal User.new(:name => name).save, true
+  end
+
+  def test_save_with_bogus_id
+    assert_equal User.new(:name_id => 100).save, false
+  end
+
+  def test_allow_nil
+    assert_equal UserWithAllowNil.new.save, true
+  end
+
+  def test_poly_relation
+    assert_equal UserWithPoly.new.save, false
+  end
+
+  def test_poly_relation_with_name
+    name = Name.create(:name => "bar")
+    assert_equal UserWithPoly.new(:relation => name).save, true
+  end
+
+  def test_poly_relation_with_allow_nil
+    assert_equal UserWithPolyAllowNil.new.save, true
+  end
+
+end
+
+

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: validates_existence
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Tanel Suurhans
@@ -10,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-20 00:00:00 +02:00
+date: 2010-04-14 00:00:00 +03:00
 default_executable: 
 dependencies: []
 
@@ -26,9 +31,11 @@ extra_rdoc_files:
 - README.markdown
 files: 
 - README.markdown
-- init.rb
 - install.rb
+- lib/rails2/validator.rb
+- lib/rails3/validator.rb
 - lib/validates_existence.rb
+- rails/init.rb
 has_rdoc: true
 homepage: http://github.com/perfectline/validates_existence/tree/master
 licenses: []
@@ -42,20 +49,28 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Validates Rails model belongs_to association existence.
-test_files: []
-
+test_files: 
+- test/models/name.rb
+- test/models/user.rb
+- test/models/user_with_allow_nil.rb
+- test/models/user_with_poly.rb
+- test/models/user_with_poly_allow_nil.rb
+- test/test_helper.rb
+- test/validates_existence_test.rb