remarkable_activerecord 3.1.8 → 3.1.9

data/lib/remarkable_activerecord/matchers/validate_acceptance_of_matcher.rb

@@ -1,50 +1,50 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateAcceptanceOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-
-        optional :accept, :message
-        optional :allow_nil, :default => true
-
-        collection_assertions :requires_acceptance?, :accept_is_valid?, :allow_nil?
-
-        default_options :message => :accepted
-
-        protected
-
-          def requires_acceptance?
-            bad?(false)
-          end
-
-          def accept_is_valid?
-            return true unless @options.key?(:accept)
-            good?(@options[:accept])
-          end
-
-      end
-
-      # Ensures that the model cannot be saved if one of the attributes listed is not accepted.
-      #
-      # == Options
-      #
-      # * <tt>:accept</tt> - the expected value to be accepted.
-      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.accepted')</tt>
-      #
-      # == Examples
-      #
-      #   should_validate_acceptance_of :eula, :terms
-      #   should_validate_acceptance_of :eula, :terms, :accept => true
-      #
-      #   it { should validate_acceptance_of(:eula, :terms) }
-      #   it { should validate_acceptance_of(:eula, :terms, :accept => true) }
-      #
-      def validate_acceptance_of(*attributes, &block)
-        ValidateAcceptanceOfMatcher.new(*attributes, &block).spec(self)
-      end
-
-    end
-  end
-end
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateAcceptanceOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :accept, :message
+        optional :allow_nil, :default => true
+
+        collection_assertions :requires_acceptance?, :accept_is_valid?, :allow_nil?
+
+        default_options :message => :accepted
+
+        protected
+
+          def requires_acceptance?
+            bad?(false)
+          end
+
+          def accept_is_valid?
+            return true unless @options.key?(:accept)
+            good?(@options[:accept])
+          end
+
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes listed is not accepted.
+      #
+      # == Options
+      #
+      # * <tt>:accept</tt> - the expected value to be accepted.
+      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.accepted')</tt>
+      #
+      # == Examples
+      #
+      #   should_validate_acceptance_of :eula, :terms
+      #   should_validate_acceptance_of :eula, :terms, :accept => true
+      #
+      #   it { should validate_acceptance_of(:eula, :terms) }
+      #   it { should validate_acceptance_of(:eula, :terms, :accept => true) }
+      #
+      def validate_acceptance_of(*attributes, &block)
+        ValidateAcceptanceOfMatcher.new(*attributes, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/validate_associated_matcher.rb

@@ -1,103 +1,103 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateAssociatedMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateAssociatedMatcher < Remarkable::ActiveRecord::Base #:nodoc:
         arguments :collection => :associations, :as => :association, :block => true
-
+
         optional :message
-        optional :builder, :block => true
-
-        collection_assertions :find_association?, :is_valid?
-        default_options :message => :invalid
-
-        protected
-
-          def find_association?
-            reflection = @subject.class.reflect_on_association(@association)
-
-            raise ScriptError, "Could not find association #{@association} on #{subject_class}." unless reflection
-
-            associated_object = if builder = @options[:builder] || @block
-              builder.call(@subject)
-            elsif [:belongs_to, :has_one].include?(reflection.macro)
-              @subject.send(:"build_#{@association}") rescue nil
-            else
-              @subject.send(@association).build rescue nil
-            end
-
-            raise ScriptError, "The association object #{@association} could not be built. You can give me " <<
-                               ":builder as option or a block which returns an association." unless associated_object
-
-            raise ScriptError, "The associated object #{@association} is not invalid. You can give me " <<
-                               ":builder as option or a block which returns an invalid association." if associated_object.save
-
-            return true
-          end
-
-          def is_valid?
-            return false if @subject.valid?
-
-            error_message_to_expect = error_message_from_model(@subject, :base, @options[:message])
-
-            # In Rails 2.1.2, the error on association returns a symbol (:invalid)
-            # instead of the message, so we check this case here.
-            @subject.errors.on(@association) == @options[:message] ||
-            assert_contains(@subject.errors.on(@association), error_message_to_expect)
-          end
-      end
-
-      # Ensures that the model is invalid if one of the associations given is
-      # invalid. It tries to build the association automatically. In has_one
-      # and belongs_to cases, it will build it like this:
-      #
-      #   @model.build_association
-      #   @project.build_manager
-      #
-      # In has_many and has_and_belongs_to_many to cases it will build it like
-      # this:
-      #
-      #   @model.association.build
-      #   @project.tasks.build
-      #
-      # The object returned MUST be invalid and it's likely the case, since the
-      # associated object is empty when calling build. However, if the associated
-      # object has to be manipulated to be invalid, you will have to give :builder
-      # as option or a block to manipulate it:
-      #
-      #   should_validate_associated(:tasks) do |project|
-      #     project.tasks.build(:captcha => 'i_am_a_bot')
-      #   end
-      #
-      # In the case above, the associated object task is only invalid when the
-      # captcha attribute is set. So we give a block to the matcher that tell
-      # exactly how to build an invalid object.
-      #
-      # The example above can also be written as:
-      #
-      #   should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
-      #
-      # == Options
-      #
-      # * <tt>:builder</tt> - a proc to build the association
-      #
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.invalid')</tt>
-      #
-      # == Examples
-      #
-      #   should_validate_associated :tasks
+        optional :builder, :block => true
+
+        collection_assertions :find_association?, :is_valid?
+        default_options :message => :invalid
+
+        protected
+
+          def find_association?
+            reflection = @subject.class.reflect_on_association(@association)
+
+            raise ScriptError, "Could not find association #{@association} on #{subject_class}." unless reflection
+
+            associated_object = if builder = @options[:builder] || @block
+              builder.call(@subject)
+            elsif [:belongs_to, :has_one].include?(reflection.macro)
+              @subject.send(:"build_#{@association}") rescue nil
+            else
+              @subject.send(@association).build rescue nil
+            end
+
+            raise ScriptError, "The association object #{@association} could not be built. You can give me " <<
+                               ":builder as option or a block which returns an association." unless associated_object
+
+            raise ScriptError, "The associated object #{@association} is not invalid. You can give me " <<
+                               ":builder as option or a block which returns an invalid association." if associated_object.save
+
+            return true
+          end
+
+          def is_valid?
+            return false if @subject.valid?
+
+            error_message_to_expect = error_message_from_model(@subject, :base, @options[:message])
+
+            # In Rails 2.1.2, the error on association returns a symbol (:invalid)
+            # instead of the message, so we check this case here.
+            @subject.errors.on(@association) == @options[:message] ||
+            assert_contains(@subject.errors.on(@association), error_message_to_expect)
+          end
+      end
+
+      # Ensures that the model is invalid if one of the associations given is
+      # invalid. It tries to build the association automatically. In has_one
+      # and belongs_to cases, it will build it like this:
+      #
+      #   @model.build_association
+      #   @project.build_manager
+      #
+      # In has_many and has_and_belongs_to_many to cases it will build it like
+      # this:
+      #
+      #   @model.association.build
+      #   @project.tasks.build
+      #
+      # The object returned MUST be invalid and it's likely the case, since the
+      # associated object is empty when calling build. However, if the associated
+      # object has to be manipulated to be invalid, you will have to give :builder
+      # as option or a block to manipulate it:
+      #
+      #   should_validate_associated(:tasks) do |project|
+      #     project.tasks.build(:captcha => 'i_am_a_bot')
+      #   end
+      #
+      # In the case above, the associated object task is only invalid when the
+      # captcha attribute is set. So we give a block to the matcher that tell
+      # exactly how to build an invalid object.
+      #
+      # The example above can also be written as:
+      #
+      #   should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      #
+      # == Options
+      #
+      # * <tt>:builder</tt> - a proc to build the association
+      #
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.invalid')</tt>
+      #
+      # == Examples
+      #
+      #   should_validate_associated :tasks
       #   should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
       #
       #   should_validate_associated :tasks do |m|
       #     m.builder { |p| p.tasks.build(:captcha => 'i_am_a_bot') }
-      #   end
-      #
-      #   it { should validate_associated(:tasks) }
-      #   it { should validate_associated(:tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }) }
-      #
-      def validate_associated(*args, &block)
-        ValidateAssociatedMatcher.new(*args, &block).spec(self)
-      end
-    end
-  end
-end
+      #   end
+      #
+      #   it { should validate_associated(:tasks) }
+      #   it { should validate_associated(:tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }) }
+      #
+      def validate_associated(*args, &block)
+        ValidateAssociatedMatcher.new(*args, &block).spec(self)
+      end
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/validate_confirmation_of_matcher.rb

@@ -1,44 +1,44 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateConfirmationOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-
-        optional :message
-        collection_assertions :responds_to_confirmation?, :confirms?
-
-        default_options :message => :confirmation
-
-        protected
-
-          def responds_to_confirmation?
-            @subject.respond_to?(:"#{@attribute}_confirmation=")
-          end
-
-          def confirms?
-            @subject.send(:"#{@attribute}_confirmation=", 'something')
-            bad?('different')
-          end
-
-      end
-
-      # Ensures that the model cannot be saved if one of the attributes is not confirmed.
-      #
-      # == Options
-      #
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.confirmation')</tt>
-      #
-      # == Examples
-      #
-      #   should_validate_confirmation_of :email, :password
-      #
-      #   it { should validate_confirmation_of(:email, :password) }
-      #
-      def validate_confirmation_of(*attributes, &block)
-        ValidateConfirmationOfMatcher.new(*attributes, &block).spec(self)
-      end
-
-    end
-  end
-end
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateConfirmationOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :message
+        collection_assertions :responds_to_confirmation?, :confirms?
+
+        default_options :message => :confirmation
+
+        protected
+
+          def responds_to_confirmation?
+            @subject.respond_to?(:"#{@attribute}_confirmation=")
+          end
+
+          def confirms?
+            @subject.send(:"#{@attribute}_confirmation=", 'something')
+            bad?('different')
+          end
+
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes is not confirmed.
+      #
+      # == Options
+      #
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.confirmation')</tt>
+      #
+      # == Examples
+      #
+      #   should_validate_confirmation_of :email, :password
+      #
+      #   it { should validate_confirmation_of(:email, :password) }
+      #
+      def validate_confirmation_of(*attributes, &block)
+        ValidateConfirmationOfMatcher.new(*attributes, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/validate_exclusion_of_matcher.rb

@@ -1,57 +1,57 @@
-require File.join(File.dirname(__FILE__), 'allow_values_for_matcher')
-
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateExclusionOfMatcher < AllowValuesForMatcher #:nodoc:
+require File.join(File.dirname(__FILE__), 'allow_values_for_matcher')
+
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateExclusionOfMatcher < AllowValuesForMatcher #:nodoc:
         # Don't allow it to behave in the negative way.
         undef_method :does_not_match?
-
-        default_options :message => :exclusion
-
-        protected
-
-          def valid_values
-            if @in_range
-              [ @options[:in].first - 1, @options[:in].last + 1 ]
+
+        default_options :message => :exclusion
+
+        protected
+
+          def valid_values
+            if @in_range
+              [ @options[:in].first - 1, @options[:in].last + 1 ]
             else
               value = @options[:in].select{ |i| i.is_a?(String) }.max
-              value ? [ value.next ] : []
-            end
-          end
-
-          def invalid_values
-            @options[:in]
-          end
-
-      end
-
-      # Ensures that given values are not valid for the attribute. If a range
-      # is given, ensures that the attribute is not valid in the given range.
-      #
-      # If you give that :username does not accept ["admin", "user"], it will
-      # test that "uses" (the next of the array max value) is allowed.
-      #
-      # == Options
-      #
-      # * <tt>:in</tt> - values to test exclusion.
-      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
-      # * <tt>:allow_blank</tt> - when supplied, validates if it allows blank or not.
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.exclusion')</tt>
-      #
-      # == Examples
-      #
-      #   it { should validate_exclusion_of(:username, :in => ["admin", "user"]) }
-      #   it { should validate_exclusion_of(:age, :in => 30..60) }
-      #
-      #   should_validate_exclusion_of :username, :in => ["admin", "user"]
-      #   should_validate_exclusion_of :age, :in => 30..60
-      #
-      def validate_exclusion_of(*args, &block)
-        ValidateExclusionOfMatcher.new(*args, &block).spec(self)
-      end
-
-    end
-  end
-end
+              value ? [ value.next ] : []
+            end
+          end
+
+          def invalid_values
+            @options[:in]
+          end
+
+      end
+
+      # Ensures that given values are not valid for the attribute. If a range
+      # is given, ensures that the attribute is not valid in the given range.
+      #
+      # If you give that :username does not accept ["admin", "user"], it will
+      # test that "uses" (the next of the array max value) is allowed.
+      #
+      # == Options
+      #
+      # * <tt>:in</tt> - values to test exclusion.
+      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
+      # * <tt>:allow_blank</tt> - when supplied, validates if it allows blank or not.
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.exclusion')</tt>
+      #
+      # == Examples
+      #
+      #   it { should validate_exclusion_of(:username, :in => ["admin", "user"]) }
+      #   it { should validate_exclusion_of(:age, :in => 30..60) }
+      #
+      #   should_validate_exclusion_of :username, :in => ["admin", "user"]
+      #   should_validate_exclusion_of :age, :in => 30..60
+      #
+      def validate_exclusion_of(*args, &block)
+        ValidateExclusionOfMatcher.new(*args, &block).spec(self)
+      end
+
+    end
+  end
+end