remarkable_activerecord 3.1.13 → 4.0.0.alpha1

data/lib/remarkable_activerecord/matchers/validate_numericality_of_matcher.rb

@@ -1,188 +0,0 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateNumericalityOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-
-        optional :equal_to, :greater_than_or_equal_to, :greater_than,
-                 :less_than_or_equal_to, :less_than, :message
-
-        optional :only_integer, :odd, :even, :allow_nil, :allow_blank, :default => true
-
-        collection_assertions :only_numeric_values?, :allow_blank?, :allow_nil?,
-                              :only_integer?, :only_odd?, :only_even?, :equals_to?,
-                              :less_than_minimum?, :more_than_maximum?
-
-        # Before assertions, we rearrange the values.
-        #
-        # Notice that :less_than gives a maximum value while :more_than given
-        # a minimum value. While :equal_to generate both.
-        #
-        before_assert do
-          @maximum_values = {}
-          @minimum_values = {}
-
-          if value = @options[:equal_to]
-            @maximum_values[:equal_to] = value
-            @minimum_values[:equal_to] = value
-          elsif value = @options[:less_than]
-            @maximum_values[:less_than] = value - 1
-          elsif value = @options[:greater_than]
-            @minimum_values[:greater_than] = value + 1
-          elsif value = @options[:less_than_or_equal_to]
-            @maximum_values[:less_than_or_equal_to] = value
-          elsif value = @options[:greater_than_or_equal_to]
-            @minimum_values[:greater_than_or_equal_to] = value
-          end
-        end
-
-        private
-
-          def allow_nil?
-            super(default_message_for(:not_a_number))
-          end
-
-          def allow_blank?
-            super(default_message_for(:not_a_number))
-          end
-
-          def only_numeric_values?
-            bad?("abcd", default_message_for(:not_a_number))
-          end
-
-          def only_integer?
-            assert_bad_or_good_if_key(:only_integer, valid_value_for_test.to_f, default_message_for(:not_a_number))
-          end
-
-          # In ActiveRecord, when we supply :even, does not matter the value, it
-          # considers that should even values should be accepted.
-          #
-          def only_even?
-            return true unless @options[:even]
-            bad?(even_valid_value_for_test + 1, default_message_for(:even))
-          end
-
-          # In ActiveRecord, when we supply :odd, does not matter the value, it
-          # considers that should odd values should be accepted.
-          #
-          def only_odd?
-            return true unless @options[:odd]
-            bad?(even_valid_value_for_test, default_message_for(:odd))
-          end
-
-          # Check equal_to for all registered values.
-          #
-          def equals_to?
-            values = {}
-            @maximum_values.each { |k, v| values[k] = v }
-            @minimum_values.each { |k, v| values[k] = v }
-
-            values.each do |key, value|
-              return false, :count => value unless good?(value, default_message_for(key))
-            end
-            true
-          end
-
-          # Check more_than_maximum? for equal_to, less_than and
-          # less_than_or_equal_to options.
-          #
-          def more_than_maximum?
-            @maximum_values.each do |key, value|
-              return false, :count => value unless bad?(value + 1, default_message_for(key))
-            end
-            true
-          end
-
-          # Check less_than_minimum? for equal_to, more_than and
-          # more_than_or_equal_to options.
-          #
-          def less_than_minimum?
-            @minimum_values.each do |key, value|
-              return false, :count => value unless bad?(value - 1, default_message_for(key))
-            end
-            true
-          end
-
-          # Returns a valid value for test.
-          #
-          def valid_value_for_test
-            value = @options[:equal_to] || @options[:less_than_or_equal_to] || @options[:greater_than_or_equal_to]
-
-            value ||= @options[:less_than]    - 1 if @options[:less_than]
-            value ||= @options[:greater_than] + 1 if @options[:greater_than]
-
-            value ||= 10
-
-            if @options[:even]
-              value = (value / 2) * 2
-            elsif @options[:odd]
-              value = ((value / 2) * 2) + 1
-            end
-
-            value
-          end
-
-          # Returns a valid even value for test.
-          # The method valid_value_for_test checks for :even option but does not
-          # return necessarily an even value
-          #
-          def even_valid_value_for_test
-            (valid_value_for_test / 2) * 2
-          end
-
-          # Returns the default message for each key (:odd, :even, :equal_to, ...).
-          # If the user provided a message, we use it, otherwise we should use
-          # the given key as message.
-          #
-          # For example, a default_message_for(:odd), if none is provided, will be
-          # :odd. So we have create :odd_message in the options hash, that when
-          # called later, will return :odd.
-          #
-          def default_message_for(key)
-            if @options[:message]
-              :message
-            else
-              @options[:"#{key}_message"] = key
-              :"#{key}_message"
-            end
-          end
-      end
-
-      # Ensures that the given attributes accepts only numbers.
-      #
-      # == Options
-      #
-      # * <tt>:only_integer</tt> - when supplied, checks if it accepts only integers or not
-      # * <tt>:odd</tt> - when supplied, checks if it accepts only odd values or not
-      # * <tt>:even</tt> - when supplied, checks if it accepts only even values or not
-      # * <tt>:equal_to</tt> - when supplied, checks if attributes are only valid when equal to given value
-      # * <tt>:less_than</tt> - when supplied, checks if attributes are only valid when less than given value
-      # * <tt>:greater_than</tt> - when supplied, checks if attributes are only valid when greater than given value
-      # * <tt>:less_than_or_equal_to</tt> - when supplied, checks if attributes are only valid when less than or equal to given value
-      # * <tt>:greater_than_or_equal_to</tt> - when supplied, checks if attributes are only valid when greater than or equal to given value
-      # * <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.not_a_number')</tt>
-      #
-      # == Examples
-      #
-      #   it { should validate_numericality_of(:age).odd }
-      #   it { should validate_numericality_of(:age).even }
-      #   it { should validate_numericality_of(:age).only_integer }
-      #   it { should validate_numericality_of(:age, :odd => true) }
-      #   it { should validate_numericality_of(:age, :even => true) }
-      #
-      #   should_validate_numericality_of :age, :price
-      #   should_validate_numericality_of :price, :only_integer => false, :greater_than => 10
-      #
-      #   should_validate_numericality_of :price do |m|
-      #     m.only_integer = false
-      #     m.greater_than = 10
-      #   end
-      #
-      def validate_numericality_of(*attributes, &block)
-        ValidateNumericalityOfMatcher.new(*attributes, &block).spec(self)
-      end
-
-    end
-  end
-end

data/lib/remarkable_activerecord/matchers/validate_presence_of_matcher.rb

@@ -1,91 +0,0 @@
-module Remarkable
-  module ActiveRecord
-    # Holds ActiveRecord matchers.
-    #
-    # == Validations matchers
-    #
-    # Remarkable supports all ActiveRecord validations, and the only options
-    # not supported in those matchers is the :on options. So whenever you have
-    # to test that a validation runs on update, you have to do reproduce the
-    # state in your tests:
-    #
-    #   describe Project do
-    #     describe 'validations on create' do
-    #       should_validate_presence_of :title
-    #     end
-    #
-    #     describe 'validations on update' do
-    #       subject { Post.create!(@valid_attributes) }
-    #       should_validate_presence_of :updated_at
-    #     end
-    #   end
-    #
-    # Another behavior in validations is the :message option. Whenever you change
-    # the message in your model, it must be given in your tests too:
-    #
-    #   class Post < ActiveRecord::Base
-    #     validates_presence_of :title, :message => 'must be filled'
-    #   end
-    #
-    #   describe Post do
-    #     should_validate_presence_of :title #=> fails
-    #     should_validate_presence_of :title, :message => 'must be filled'
-    #   end
-    #
-    # However, if you change the title using the I18n API, you don't need to
-    # specify the message in your tests, because it's retrieved properly.
-    #
-    module Matchers
-      class ValidatePresenceOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-        optional  :message
-
-        collection_assertions :allow_nil?
-        default_options :message => :blank
-
-        protected
-
-          def allow_nil?
-            bad?(blank_value, :message)
-          end
-
-          def blank_value
-            collection? ? [] : nil
-          end
-
-          def collection?
-            if reflection = find_reflection
-              [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
-            else
-              false
-            end
-          end
-
-        private
-
-          def find_reflection
-            if subject_class.respond_to?(:reflect_on_association)
-              subject_class.reflect_on_association(@attribute)
-            end
-          end
-
-      end
-
-      # Ensures that the model cannot be saved if one of the attributes listed is not present.
-      #
-      # == 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.blank')</tt>
-      #
-      # == Examples
-      #
-      #   should_validate_presence_of :name, :phone_number
-      #   it { should validate_presence_of(:name, :phone_number) }
-      #
-      def validate_presence_of(*args, &block)
-        ValidatePresenceOfMatcher.new(*args, &block).spec(self)
-      end
-    end
-  end
-end