validates_existence 0.5.2 → 0.5.3

data/README.markdown

@@ -7,6 +7,11 @@ It also supports `:allow_nil => true/false` and `:polymorphic => true` associati
 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.3
+
+Cleaned up the code, the whole library is now in one file with separate modules for Rails 2 and Rails 3.
+Also renamed `should_macros` folder to `shoulda`.
+
 #### 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.
@@ -14,6 +19,12 @@ For example if the validation was on `:relation_id` field, then the error was ac
 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.
 
+#### TODO
+
++ replace T::U tests with RSpec
++ create RSpec Matcher
++ separate set of tests for Rails 3
+
 ### Installation
 First install the gem:
     sudo gem install validates_existence
@@ -57,7 +68,7 @@ First install the gem:
       validates :person,    :existence => { :allow_nil => true, :both => false }
 
       # the old method is supported also
-      validates_existence :wizard
+      validates_existence_of :wizard
     end
     
 ## I18N

data/lib/validates_existence.rb

@@ -1,11 +1,97 @@
-if Rails::VERSION::MAJOR >= 3
-  require "active_model"
-  require "rails3/validator"
+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.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
+
+    module Rails3
+      extend ActiveSupport::Concern
+
+      class ExistenceValidator < ActiveModel::EachValidator
 
-  ActiveModel::Validations.__send__(:include, Perfectline::ValidatesExistence::InstanceMethods)
-  ActiveModel::Validations.__send__(:extend,  Perfectline::ValidatesExistence::ClassMethods)
+        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 value.nil? or 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
+
+      module ClassMethods
+        def validates_existence_of(*attr_names)
+          validates_with ExistenceValidator, _merge_attributes(attr_names)
+        end
+      end
+
+    end
+  end
+end
+
+if Rails::VERSION::MAJOR >= 3
+  ActiveRecord::Base.send(:include, Perfectline::ValidatesExistence::Rails3)
 else
-  require "rails2/validator"
-  
-  ActiveRecord::Base.__send__(:extend, Perfectline::ValidatesExistence)
-end
+  ActiveRecord::Base.send(:extend,  Perfectline::ValidatesExistence::Rails2)
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 5
-  - 2
-  version: 0.5.2
+  - 3
+  version: 0.5.3
 platform: ruby
 authors: 
 - Tanel Suurhans
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-15 00:00:00 +03:00
+date: 2010-09-05 00:00:00 +03:00
 default_executable: 
 dependencies: []
 
@@ -32,10 +32,17 @@ extra_rdoc_files:
 files: 
 - README.markdown
 - install.rb
-- lib/rails2/validator.rb
-- lib/rails3/validator.rb
 - lib/validates_existence.rb
 - rails/init.rb
+- test/models/user_with_poly.rb
+- test/models/name.rb
+- test/models/user_with_allow_nil.rb
+- test/models/user_with_has_many.rb
+- test/models/user_with_poly_allow_nil.rb
+- test/models/user_with_both.rb
+- test/models/user.rb
+- test/validates_existence_test.rb
+- test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/perfectline/validates_existence/tree/master
 licenses: []
@@ -46,6 +53,7 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -53,6 +61,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -62,17 +71,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Validates Rails model belongs_to association existence.
 test_files: 
+- test/models/user_with_poly.rb
 - 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
+- test/models/user_with_both.rb
+- test/models/user.rb
 - test/validates_existence_test.rb
+- test/test_helper.rb

data/lib/rails2/validator.rb

@@ -1,40 +0,0 @@
-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,55 +0,0 @@
-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