carlosbrando-remarkable 0.0.99 → 2.2.1

data/lib/remarkable/active_record/macros/validations/validate_associated_matcher.rb

@@ -0,0 +1,177 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class ValidateAssociatedMatcher < Remarkable::Matcher::Base
+        include Remarkable::ActiveRecord::Helpers
+
+        undef_method :allow_nil, :allow_nil?, :allow_blank, :allow_blank?
+
+        def initialize(*associations)
+          load_options(associations.extract_options!)
+          @associations = associations
+        end
+
+        def builder(value)
+          @options[:builder] = value
+          self
+        end
+
+        def matches?(subject)
+          @subject = get_instance_of(subject)
+
+          assert_matcher_for(@associations) do |association|
+            @association = association
+            build_association? && valid?
+          end
+        end
+
+        def description
+          "require association #{@associations.to_sentence} to be valid"
+        end
+
+        private
+
+        # Try to build the association. First we check if the user sent
+        # a builder as proc. An example of proc given could be:
+        #
+        #   proc { |subject| subject.associations.build }
+        #
+        # Second we attempt to get a instance variable with the singular name
+        # of the association. If not possible, we finally try:
+        #
+        #   subject.associations.build
+        #
+        # Our last option is:
+        #
+        #   subject.build_association
+        #
+        def build_association?
+          @plural             = @association.to_s.pluralize
+          @singular           = @plural.singularize
+          @association_object = nil
+
+          if @options[:builder].is_a? Proc
+            @association_object = @options[:builder].call(@subject)
+          elsif !@spec.instance_variable_get("@#{@singular}").nil?
+            @association_object = @spec.instance_variable_get("@#{@singular}")
+          end
+
+          if plural?
+            if @association_object # Append the association if already found
+              @subject.send(@plural).send('<<', @association_object)
+            elsif @subject.send(@plural).respond_to?(:build)
+              @association_object = @subject.send(@plural).send(:build)
+            end
+          elsif singular?
+            if @association_object # Set the association if already found
+              @subject.send("#{@singular}=", @association_object)
+            elsif @subject.respond_to?("build_#{@singular}")
+              @association_object = @subject.send("build_#{@singular}")
+            end
+          end
+
+          return true if @association_object
+
+          @missing = "cannot build association, tried to find instance variable " +
+                     "@#{subject_name.downcase}, then tried @#{subject_name.downcase}.#{@plural}.build " +
+                     "and @#{subject_name.downcase}.build_#{@singular} without success."
+
+          @missing << " Please give a proc as optional :builder to build the association." unless @options[:builder].is_a? Proc
+
+          return false
+        end
+
+        def valid?
+          # Try to save the association
+          association_saved = if plural?
+            @subject.send(@plural).last.save
+          elsif singular?
+            @subject.send(@singular).save
+          end
+
+          if association_saved
+            @missing = "the given association #{@association} cannot be saved with errors"
+            return false
+          end
+
+          @subject.save
+
+          error_message_to_expect = error_message_from_model(@subject, :base, @options[:message])
+          return true if assert_contains(@subject.errors.on(plural? ? @plural : @singular), error_message_to_expect)
+
+          @missing = "#{subject_class} is not invalid when #{@association} is invalid"
+          false
+        end
+
+        # Receives a Hash
+        def load_options(options = {})
+          @options = {
+            :message => :invalid
+          }.merge(options)
+        end
+
+        def plural?
+          @subject.respond_to? @plural
+        end
+
+        def singular?
+          @subject.respond_to? @singular
+        end
+
+        def expectation
+          "that #{subject_name} is invalid if #{@association} is invalid"
+        end
+      end
+
+      # Ensures that the model is invalid if one of the associations given is
+      # invalid.
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # It tries to build an instance of the association by two ways. Let's
+      # suppose a user that has many projects and you want to validate it:
+      #
+      #   it { should validate_associated(:projects) }
+      #
+      # The first attempt to build the association would be:
+      #
+      #   @user.projects.build
+      #
+      # If not possible, then we try:
+      #
+      #   @user.build_project
+      #
+      # Then it tries to save the associated object. If the object can be saved
+      # if success (in this case, it allows all attributes as blank), we won't
+      # be able to verify the validation and then an error will be raised. In
+      # such cases, you should instantiate the association before calling the
+      # matcher:
+      #
+      #   it do
+      #     @user = User.new
+      #     @project = @user.projects.build
+      #     should validate_associated(:projects)
+      #   end
+      #
+      # Or give :builder as option:
+      #
+      #   should_validate_associated :projects, :builder => proc { |user| user.projects.build }
+      #
+      # 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>
+      #
+      # Example:
+      #
+      #   it { should validate_associated(:projects, :account) }
+      #   it { should validate_associated(:projects, :builder => proc { |user| user.projects.build }) }
+      #
+      def validate_associated(*attributes)
+        ValidateAssociatedMatcher.new(*attributes)
+      end
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/validate_confirmation_of_matcher.rb

@@ -0,0 +1,74 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class ValidateConfirmationOfMatcher < Remarkable::Matcher::Base
+        include Remarkable::ActiveRecord::Helpers
+
+        undef_method :allow_nil?, :allow_nil, :allow_blank?, :allow_blank
+
+        def initialize(*attributes)
+          load_options(attributes.extract_options!)
+          @attributes = attributes
+        end
+
+        def matches?(subject)
+          @subject = get_instance_of(subject)
+
+          assert_matcher_for(@attributes) do |attribute|
+            @attribute = attribute
+            confirmed?
+          end
+        end
+
+        def description
+          "validate confirmation of #{@attributes.to_sentence}"
+        end
+
+        private
+
+        def confirmed?
+          confirmation_assignment = "#{@attribute}_confirmation="
+
+          if @subject.respond_to? confirmation_assignment
+            @subject.send(confirmation_assignment, 'something')
+            return true if bad?('different')
+
+            @missing = "#{subject_name} is valid even if confirmation does not match"
+            return false
+          else
+            @missing = "#{subject_name} does not respond to #{confirmation_assignment}"
+            return false
+          end
+        end
+
+        def load_options(options = {})
+          @options = {
+            :message => :confirmation
+          }.merge(options)
+        end
+
+        def expectation
+          "#{@attribute} to be confirmed"
+        end
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes is not confirmed.
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # 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>
+      #
+      # Example:
+      #   it { should validate_confirmation_of(:email, :password) }
+      #
+      def validate_confirmation_of(*attributes)
+        ValidateConfirmationOfMatcher.new(*attributes)
+      end
+
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/validate_exclusion_of_matcher.rb

@@ -0,0 +1,38 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+
+      # 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 an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Note: this matcher accepts at once just one attribute to test.
+      #
+      # Options:
+      #
+      # * <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>
+      #
+      # Example:
+      #
+      #   it { should validate_exclusion_of(:username, "admin", "user") }
+      #   it { should_not validate_exclusion_of(:username, "clark_kent", "peter_park") }
+      #
+      #   it { should validate_exclusion_of(:age, 30..60) }
+      #
+      def validate_exclusion_of(attribute, *good_values)
+        if good_values.first.is_a? Range
+          EnsureValueInRangeMatcher.new(attribute, :exclusion, *good_values)
+        else
+          EnsureValueInListMatcher.new(attribute, :exclusion, *good_values)
+        end
+      end
+
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/validate_format_of_matcher.rb

@@ -0,0 +1,33 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+
+      # Ensures that the attribute can be set to the given values.
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Note: this matcher accepts at once just one attribute to test.
+      # Note: this matcher is also aliased as "allow_values_for"
+      #
+      # Options:
+      #
+      # * <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.invalid')</tt>
+      #
+      # Example:
+      #
+      #   it { should validate_format_of(:isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0") }
+      #   it { should_not validate_format_of(:isbn, "bad 1", "bad 2") }
+      #
+      def validate_format_of(attribute, *good_values)
+        EnsureValueInListMatcher.new(attribute, :invalid, *good_values)
+      end
+      alias :allow_values_for :validate_format_of
+
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/validate_inclusion_of_matcher.rb

@@ -0,0 +1,45 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+
+      # Ensures that given values are valid for the attribute. If a range
+      # is given, ensures that the attribute is valid in the given range.
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Note: this matcher accepts at once just one attribute to test.
+      #
+      # Options:
+      #
+      # * <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.inclusion')</tt>
+      #
+      # Example:
+      #
+      #   it { should validate_inclusion_of(:isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0") }
+      #   it { should_not validate_inclusion_of(:isbn, "bad 1", "bad 2") }
+      #
+      #   it { should validate_inclusion_of(:age, 18..100) }
+      #
+      def validate_inclusion_of(attribute, *good_values)
+        if good_values.first.is_a? Range
+          EnsureValueInRangeMatcher.new(attribute, :inclusion, *good_values)
+        else
+          EnsureValueInListMatcher.new(attribute, :inclusion, *good_values)
+        end
+      end
+
+      # TODO This one is for shoulda compatibility. Deprecate it?
+      def ensure_inclusion_of(attribute, *good_values) #:nodoc:
+        warn "[DEPRECATION] should_ensure_inclusion_of is deprecated. " <<
+             "Use should_validate_inclusion_of instead."
+        validate_inclusion_of(attribute, *good_values)
+      end
+
+    end
+  end
+end

data/lib/remarkable/active_record/macros/validations/validate_length_of_matcher.rb

@@ -0,0 +1,248 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers # :nodoc:
+      class ValidateLengthOfMatcher < Remarkable::Matcher::Base
+        include Remarkable::ActiveRecord::Helpers
+
+        def initialize(attributes, range, behavior, options = {})
+          @attributes = attributes
+          @behavior   = behavior
+
+          # Set the values, for example:
+          #
+          #   send(:within, 0..10)
+          #
+          send(@behavior, range)
+
+          load_options(options)
+        end
+
+        # If message is supplied, reassign it properly to :short_message
+        # and :long_message. This is ActiveRecord default behavior when
+        # the validation is :maximum, :minimum or :is.
+        #
+        def message(message)
+          if [:is, :minimum, :maximum].include? @behavior
+            short_message(message)
+            long_message(message)
+          end
+          self
+        end
+
+        def within(range)
+          @behavior = :within
+          @minimum  = range.first
+          @maximum  = range.last
+          self
+        end
+        alias :in :within
+
+        def minimum(value)
+          @minimum = value
+          self
+        end
+
+        def maximum(value)
+          @maximum = value
+          self
+        end
+
+        def is(value)
+          @minimum = value
+          @maximum = value
+          self
+        end
+
+        def short_message(message)
+          @options[:short_message] = message
+          @options[:message] = message # make a copy in @options[:message], for
+                                       # allow_blank and allow_nil work properly.
+          self
+        end
+
+        def long_message(message)
+          @options[:long_message] = message
+          self
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          assert_matcher_for(@attributes) do |attribute|
+            @attribute = attribute
+
+            less_than_min_length? && exactly_min_length? && allow_nil?(:message, @minimum) &&
+            more_than_max_length? && exactly_max_length? && allow_blank?(:message, @minimum)
+          end
+        end
+
+        def description
+          "ensure #{expectation}"
+        end
+
+        def failure_message
+          "Expected #{expectation} (#{@missing})"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        private
+
+        def less_than_min_length?
+          return true if @behavior == :maximum || @minimum <= 0
+          return true if bad?(value_for_length(@minimum - 1), :short_message, @minimum)
+
+          @missing = "allow #{@attribute} to be less than #{@minimum} chars long"
+          return false
+        end
+
+        def exactly_min_length?
+          return true if @behavior == :maximum || @minimum <= 0
+          return true if good?(value_for_length(@minimum), :short_message, @minimum)
+
+          @missing = "not allow #{@attribute} to be exactly #{@minimum} chars long"
+          return false
+        end
+
+        def more_than_max_length?
+          return true if @behavior == :minimum
+          return true if bad?(value_for_length(@maximum + 1), :long_message, @maximum)
+
+          @missing = "allow #{@attribute} to be more than #{@maximum} chars long"
+          return false
+        end
+
+        def exactly_max_length?
+          return true if @behavior == :minimum || @minimum == @maximum
+          return true if good?(value_for_length(@maximum), :long_message, @maximum)
+
+          @missing = "not allow #{@attribute} to be exactly #{@maximum} chars long"
+          return false
+        end
+
+        def load_options(options)
+          if @behavior == :is
+            @options = {
+              :short_message => :wrong_length,
+              :long_message => :wrong_length
+            }.merge(options)
+          else
+            @options = {
+              :short_message => :too_short,
+              :long_message => :too_long
+            }.merge(options)
+          end
+
+          # Reassign messages properly
+          message(@options[:message]) if @options[:message]
+          long_message(@options[:long_message])
+          short_message(@options[:short_message])
+        end
+
+        def expectation
+          message = "that the length of the #{@attribute} is "
+
+          message << if @behavior == :within
+            "between #{@minimum} and #{@maximum}"
+          elsif @behavior == :minimum
+            "more than #{@minimum}"
+          elsif @behavior == :maximum
+            "less than #{@maximum}"
+          else #:is
+            "equal to #{@minimum}"
+          end
+
+          message << " or nil"   if @options[:allow_nil]
+          message << " or blank" if @options[:allow_blank]
+          message
+        end
+
+        def value_for_length(value)
+          "x" * value
+        end
+      end
+
+      # Validates the length of the given attributes. You have also to supply
+      # one of the following options: minimum, maximum, is or within.
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Note: this method is also aliased as <tt>validate_size_of</tt>.
+      #
+      # Options:
+      #
+      # * <tt>:minimum</tt> - The minimum size of the attribute.
+      # * <tt>:maximum</tt> - The maximum size of the attribute.
+      # * <tt>:is</tt> - The exact size of the attribute.
+      # * <tt>:within</tt> - A range specifying the minimum and maximum size of the attribute.
+      # * <tt>:in</tt> - A synonym(or alias) for :within.
+      # * <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>:short_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.too_short') % range.first</tt>
+      # * <tt>:long_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.too_long') % range.last</tt>
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt> only when :minimum, :maximum or :is is given.
+      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % value</tt>
+      #
+      # Example:
+      #
+      #   it { should validate_length_of(:password, :within => 6..20) }
+      #   it { should validate_length_of(:password, :maximum => 20) }
+      #   it { should validate_length_of(:password, :minimum => 6) }
+      #   it { should validate_length_of(:age, :is => 18) }
+      #
+      #   it { should validate_length_of(:password).within(6..20) }
+      #   it { should validate_length_of(:password).maximum(20) }
+      #   it { should validate_length_of(:password).minimum(6) }
+      #   it { should validate_length_of(:age).is(18) }
+      #
+      def validate_length_of(*attributes)
+        matcher = nil
+        options = attributes.extract_options!
+
+        [:within, :in, :maximum, :minimum, :is].each do |behavior|
+          if options.key? behavior
+            matcher ||= ValidateLengthOfMatcher.new(attributes, options.delete(behavior), behavior, options)
+          end
+        end
+
+        raise ArgumentError, 'You have to give one of these options: :within, :is, :maximum or :minimum.' if matcher.nil?
+        matcher
+      end
+      alias :validate_size_of :validate_length_of
+
+      # TODO This one is for shoulda compatibility. Deprecate it?
+      def ensure_length_of(*attributes) #:nodoc:
+        warn "[DEPRECATION] should_ensure_length_of is deprecated. " <<
+             "Use should_validate_length_of instead."
+        validate_length_of(*attributes)
+      end
+
+      # TODO Deprecate me
+      def ensure_length_in_range(attribute, range, options = {}) #:nodoc:
+        warn "[DEPRECATION] should_ensure_length_in_range is deprecated. " <<
+             "Use should_validate_length_of(#{attribute.inspect}, :in => #{range.inspect}) instead."
+        ValidateLengthOfMatcher.new([attribute], range, :within, options)
+      end
+
+      # TODO Deprecate me
+      def ensure_length_at_least(attribute, range, options = {}) #:nodoc:
+        warn "[DEPRECATION] should_ensure_length_at_least is deprecated. " <<
+             "Use should_validate_length_of(#{attribute.inspect}, :minimum => #{range.inspect}) instead."
+        ValidateLengthOfMatcher.new([attribute], range, :minimum, options)
+      end
+
+      # TODO Deprecate me
+      def ensure_length_is(attribute, range, options = {}) #:nodoc:
+        warn "[DEPRECATION] should_ensure_length_is is deprecated. " <<
+             "Use should_validate_length_of(#{attribute.inspect}, :is => #{range.inspect}) instead."
+        ValidateLengthOfMatcher.new([attribute], range, :is, options)
+      end
+    end
+  end
+end