shoulda 2.11.3 → 3.0.0.beta1

data/lib/shoulda/active_record/matchers/have_readonly_attribute_matcher.rb

@@ -1,59 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensures that the attribute cannot be changed once the record has been
-      # created.
-      #
-      #   it { should have_readonly_attributes(:password) }
-      #
-      def have_readonly_attribute(value)
-        HaveReadonlyAttributeMatcher.new(value)
-      end
-
-      class HaveReadonlyAttributeMatcher # :nodoc:
-
-        def initialize(attribute)
-          @attribute = attribute.to_s
-        end
-
-        def matches?(subject)
-          @subject = subject
-          if readonly_attributes.include?(@attribute)
-            @negative_failure_message =
-              "Did not expect #{@attribute} to be read-only"
-            true
-          else
-            if readonly_attributes.empty?
-              @failure_message = "#{class_name} attribute #{@attribute} " <<
-                "is not read-only"
-            else
-              @failure_message = "#{class_name} is making " <<
-                "#{readonly_attributes.to_sentence} " <<
-                "read-only, but not #{@attribute}."
-            end
-            false
-          end
-        end
-
-        attr_reader :failure_message, :negative_failure_message
-
-        def description
-          "make #{@attribute} read-only"
-        end
-
-        private
-
-        def readonly_attributes
-          @readonly_attributes ||= (@subject.class.readonly_attributes || [])
-        end
-
-        def class_name
-          @subject.class.name
-        end
-
-      end
-
-    end
-  end
-end

data/lib/shoulda/active_record/matchers/validate_acceptance_of_matcher.rb

@@ -1,41 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensures that the model cannot be saved the given attribute is not
-      # accepted.
-      #
-      # Options:
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. Regexp or string.  Defaults to the
-      #   translation for <tt>:accepted</tt>.
-      #
-      # Example:
-      #   it { should validate_acceptance_of(:eula) }
-      #
-      def validate_acceptance_of(attr)
-        ValidateAcceptanceOfMatcher.new(attr)
-      end
-
-      class ValidateAcceptanceOfMatcher < ValidationMatcher # :nodoc:
-
-        def with_message(message)
-          @expected_message = message if message
-          self
-        end
-
-        def matches?(subject)
-          super(subject)
-          @expected_message ||= :accepted
-          disallows_value_of(false, @expected_message)
-        end
-
-        def description
-          "require #{@attribute} to be accepted"
-        end
-
-      end
-
-    end
-  end
-end

data/lib/shoulda/active_record/matchers/validate_format_of_matcher.rb

@@ -1,65 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensures that the model is not valid if the given attribute is not
-      # formatted correctly.
-      #
-      # Options:
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. <tt>Regexp</tt> or <tt>String</tt>.
-      #   Defaults to the translation for <tt>:blank</tt>.
-      # * <tt>with(string to test against)</tt>
-      # * <tt>not_with(string to test against)</tt>
-      #
-      # Examples:
-      #   it { should validate_format_of(:name).
-      #                 with('12345').
-      #                 with_message(/is not optional/) }
-      #   it { should validate_format_of(:name).
-      #                 not_with('12D45').
-      #                 with_message(/is not optional/) }
-      #
-      def validate_format_of(attr)
-        ValidateFormatOfMatcher.new(attr)
-      end
-
-      class ValidateFormatOfMatcher < ValidationMatcher # :nodoc:
-
-        def initialize(attribute)
-          super
-        end
-
-        def with_message(message)
-          @expected_message = message if message
-          self
-        end
-
-        def with(value)
-          raise "You may not call both with and not_with" if @value_to_fail
-          @value_to_pass = value
-          self
-        end
-
-        def not_with(value)
-          raise "You may not call both with and not_with" if @value_to_pass
-          @value_to_fail = value
-          self
-        end
-
-        def matches?(subject)
-          super(subject)
-          @expected_message ||= :blank
-          return disallows_value_of(@value_to_fail, @expected_message) if @value_to_fail
-          allows_value_of(@value_to_pass, @expected_message) if @value_to_pass
-        end
-
-        def description
-          "#{@attribute} have a valid format"
-        end
-
-      end
-
-    end
-  end
-end

data/lib/shoulda/active_record/matchers/validate_numericality_of_matcher.rb

@@ -1,39 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensure that the attribute is numeric
-      #
-      # Options:
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. Regexp or string.  Defaults to the
-      #   translation for <tt>:not_a_number</tt>.
-      #
-      # Example:
-      #   it { should validate_numericality_of(:age) }
-      #
-      def validate_numericality_of(attr)
-        ValidateNumericalityOfMatcher.new(attr)
-      end
-
-      class ValidateNumericalityOfMatcher < ValidationMatcher # :nodoc:
-
-        def with_message(message)
-          @expected_message = message if message
-          self
-        end
-
-        def matches?(subject)
-          super(subject)
-          @expected_message ||= :not_a_number
-          disallows_value_of('abcd', @expected_message)
-        end
-
-        def description
-          "only allow numeric values for #{@attribute}"
-        end
-      end
-
-    end
-  end
-end

data/lib/shoulda/active_record/matchers/validate_presence_of_matcher.rb

@@ -1,60 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensures that the model is not valid if the given attribute is not
-      # present.
-      #
-      # Options:
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. <tt>Regexp</tt> or <tt>String</tt>.
-      #   Defaults to the translation for <tt>:blank</tt>.
-      #
-      # Examples:
-      #   it { should validate_presence_of(:name) }
-      #   it { should validate_presence_of(:name).
-      #                 with_message(/is not optional/) }
-      #
-      def validate_presence_of(attr)
-        ValidatePresenceOfMatcher.new(attr)
-      end
-
-      class ValidatePresenceOfMatcher < ValidationMatcher # :nodoc:
-
-        def with_message(message)
-          @expected_message = message if message
-          self
-        end
-
-        def matches?(subject)
-          super(subject)
-          @expected_message ||= :blank
-          disallows_value_of(blank_value, @expected_message)
-        end
-
-        def description
-          "require #{@attribute} to be set"
-        end
-
-        private
-
-        def blank_value
-          if collection?
-            []
-          else
-            nil
-          end
-        end
-
-        def collection?
-          if reflection = @subject.class.reflect_on_association(@attribute)
-            [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
-          else
-            false
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/shoulda/active_record/matchers/validate_uniqueness_of_matcher.rb

@@ -1,148 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      # Ensures that the model is invalid if the given attribute is not unique.
-      #
-      # Internally, this uses values from existing records to test validations,
-      # so this will always fail if you have not saved at least one record for
-      # the model being tested, like so:
-      #
-      #   describe User do
-      #     before(:each) { User.create!(:email => 'address@example.com') }
-      #     it { should validate_uniqueness_of(:email) }
-      #   end
-      #
-      # Options:
-      #
-      # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. <tt>Regexp</tt> or <tt>String</tt>.
-      #   Defaults to the translation for <tt>:taken</tt>.
-      # * <tt>scoped_to</tt> - field(s) to scope the uniqueness to.
-      # * <tt>case_insensitive</tt> - ensures that the validation does not
-      #   check case. Off by default. Ignored by non-text attributes.
-      #
-      # Examples:
-      #   it { should validate_uniqueness_of(:keyword) }
-      #   it { should validate_uniqueness_of(:keyword).with_message(/dup/) }
-      #   it { should validate_uniqueness_of(:email).scoped_to(:name) }
-      #   it { should validate_uniqueness_of(:email).
-      #                 scoped_to(:first_name, :last_name) }
-      #   it { should validate_uniqueness_of(:keyword).case_insensitive }
-      #
-      def validate_uniqueness_of(attr)
-        ValidateUniquenessOfMatcher.new(attr)
-      end
-
-      class ValidateUniquenessOfMatcher < ValidationMatcher # :nodoc:
-        include Helpers
-
-        def initialize(attribute)
-          @attribute = attribute
-        end
-
-        def scoped_to(*scopes)
-          @scopes = [*scopes].flatten
-          self
-        end
-
-        def with_message(message)
-          @expected_message = message
-          self
-        end
-
-        def case_insensitive
-          @case_insensitive = true
-          self
-        end
-
-        def description
-          result = "require "
-          result << "case sensitive " unless @case_insensitive
-          result << "unique value for #{@attribute}"
-          result << " scoped to #{@scopes.join(', ')}" unless @scopes.blank?
-          result
-        end
-
-        def matches?(subject)
-          @subject = subject.class.new
-          @expected_message ||= :taken
-          find_existing &&
-            set_scoped_attributes &&
-            validate_attribute &&
-            validate_after_scope_change
-        end
-
-        private
-
-        def find_existing
-          if @existing = @subject.class.find(:first)
-            true
-          else
-            @failure_message = "Can't find first #{class_name}"
-            false
-          end
-        end
-
-        def set_scoped_attributes
-          unless @scopes.blank?
-            @scopes.each do |scope|
-              setter = :"#{scope}="
-              unless @subject.respond_to?(setter)
-                @failure_message =
-                  "#{class_name} doesn't seem to have a #{scope} attribute."
-                return false
-              end
-              @subject.send("#{scope}=", @existing.send(scope))
-            end
-          end
-          true
-        end
-
-        def validate_attribute
-          disallows_value_of(existing_value, @expected_message)
-        end
-
-        # TODO:  There is a chance that we could change the scoped field
-        # to a value that's already taken.  An alternative implementation
-        # could actually find all values for scope and create a unique
-        def validate_after_scope_change
-          if @scopes.blank?
-            true
-          else
-            @scopes.all? do |scope|
-              previous_value = @existing.send(scope)
-
-              # Assume the scope is a foreign key if the field is nil
-              previous_value ||= 0
-
-              next_value = previous_value.next
-
-              @subject.send("#{scope}=", next_value)
-
-              if allows_value_of(existing_value, @expected_message)
-                @negative_failure_message <<
-                  " (with different value of #{scope})"
-                true
-              else
-                @failure_message << " (with different value of #{scope})"
-                false
-              end
-            end
-          end
-        end
-
-        def class_name
-          @subject.class.name
-        end
-
-        def existing_value
-          value = @existing.send(@attribute)
-          value.swapcase! if @case_insensitive && value.respond_to?(:swapcase!)
-          value
-        end
-      end
-
-    end
-  end
-end

data/lib/shoulda/active_record/matchers/validation_matcher.rb

@@ -1,56 +0,0 @@
-module Shoulda # :nodoc:
-  module ActiveRecord # :nodoc:
-    module Matchers
-
-      class ValidationMatcher # :nodoc:
-
-        attr_reader :failure_message
-
-        def initialize(attribute)
-          @attribute = attribute
-        end
-
-        def negative_failure_message
-          @negative_failure_message || @failure_message
-        end
-
-        def matches?(subject)
-          @subject = subject
-          false
-        end
-
-        private
-
-        def allows_value_of(value, message = nil)
-          allow = AllowValueMatcher.
-            new(value).
-            for(@attribute).
-            with_message(message)
-          if allow.matches?(@subject)
-            @negative_failure_message = allow.failure_message
-            true
-          else
-            @failure_message = allow.negative_failure_message
-            false
-          end
-        end
-
-        def disallows_value_of(value, message = nil)
-          disallow = AllowValueMatcher.
-            new(value).
-            for(@attribute).
-            with_message(message)
-          if disallow.matches?(@subject)
-            @failure_message = disallow.negative_failure_message
-            false
-          else
-            @negative_failure_message = disallow.failure_message
-            true
-          end
-        end
-      end
-
-    end
-  end
-end
-