remarkable_activerecord 3.1.13 → 4.0.0.alpha1

data/lib/remarkable_activerecord/matchers/allow_values_for_matcher.rb

@@ -1,88 +0,0 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class AllowValuesForMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        include Remarkable::Negative
-        arguments :collection => :attributes, :as => :attribute
-
-        optional :message
-        optional :in, :splat => true
-        optional :allow_nil, :allow_blank, :default => true
-
-        collection_assertions :is_valid?, :is_invalid?, :allow_nil?, :allow_blank?
-
-        default_options :message => /.*/
-
-        before_assert do
-          first_value = @options[:in].is_a?(Array) ? @options[:in].first : @options[:in]
-          @in_range = first_value.is_a?(Range)
-
-          @options[:in] = if @in_range
-            first_value.to_a[0,2] + first_value.to_a[-2,2]
-          else
-            [*@options[:in]].compact
-          end
-
-          @options[:in].uniq!
-        end
-
-        protected
-
-          def is_valid?
-            assert_collection :value, valid_values do |value|
-              good?(value)
-            end
-          end
-
-          def is_invalid?
-            assert_collection :value, invalid_values do |value|
-              bad?(value)
-            end
-          end
-
-          def valid_values
-            @options[:in]
-          end
-
-          def invalid_values
-            []
-          end
-
-          def interpolation_options
-            options = if @in_range
-              { :in => (@options[:in].first..@options[:in].last).inspect }
-            elsif @options[:in].is_a?(Array)
-              { :in => array_to_sentence(@options[:in], true, '[]') }
-            else
-              { :in => @options[:in].inspect }
-            end
-
-            options.merge!(:behavior => @behavior.to_s)
-          end
-
-      end
-
-      # Ensures that the attribute can be set to the given values. It checks
-      # for any message in the given attribute unless a :message is explicitely
-      # given.
-      #
-      # == 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>/.*/</tt>
-      #
-      # == Examples
-      #
-      #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
-      #   it { should allow_values_for(:isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0") }
-      #
-      def allow_values_for(attribute, *args, &block)
-        options = args.extract_options!
-        AllowValuesForMatcher.new(attribute, options.merge!(:in => args), &block).spec(self)
-      end
-
-    end
-  end
-end

data/lib/remarkable_activerecord/matchers/validate_acceptance_of_matcher.rb

@@ -1,50 +0,0 @@
-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_confirmation_of_matcher.rb

@@ -1,44 +0,0 @@
-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 +0,0 @@
-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 ]
-            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

data/lib/remarkable_activerecord/matchers/validate_inclusion_of_matcher.rb

@@ -1,57 +0,0 @@
-require File.join(File.dirname(__FILE__), 'allow_values_for_matcher')
-
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateInclusionOfMatcher < AllowValuesForMatcher #:nodoc:
-        # Don't allow it to behave in the negative way.
-        undef_method :does_not_match?
-
-        default_options :message => :inclusion
-
-        protected
-
-          def valid_values
-            @options[:in]
-          end
-
-          def invalid_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
-
-      end
-
-      # 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 you give that :size accepts ["S", "M", "L"], it will test that "T"
-      # (the next of the array max value) is not allowed.
-      #
-      # == Options
-      #
-      # * <tt>:in</tt> - values to test inclusion.
-      # * <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>
-      #
-      # == Examples
-      #
-      #   should_validate_inclusion_of :size, :in => ["S", "M", "L", "XL"]
-      #   should_validate_inclusion_of :age, :in => 18..100
-      #
-      #   it { should validate_inclusion_of(:size, :in => ["S", "M", "L", "XL"]) }
-      #   it { should validate_inclusion_of(:age, :in => 18..100) }
-      #
-      def validate_inclusion_of(*args, &block)
-        ValidateInclusionOfMatcher.new(*args, &block).spec(self)
-      end
-
-    end
-  end
-end

data/lib/remarkable_activerecord/matchers/validate_length_of_matcher.rb

@@ -1,150 +0,0 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateLengthOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-
-        optional :within, :alias => :in
-        optional :minimum, :maximum, :is
-        optional :token, :separator, :with_kind_of
-        optional :allow_nil, :allow_blank, :default => true
-        optional :message, :too_short, :too_long, :wrong_length
-
-        collection_assertions :less_than_min_length?, :exactly_min_length?,
-                              :more_than_max_length?, :exactly_max_length?,
-                              :allow_nil?, :allow_blank?
-
-        before_assert do
-          # Reassign :in to :within
-          @options[:within] ||= @options.delete(:in) if @options.key?(:in)
-
-          if @options[:is]
-            @min_value, @max_value = @options[:is], @options[:is]
-          elsif @options[:within]
-            @min_value, @max_value = @options[:within].first, @options[:within].last
-          elsif @options[:maximum]
-            @min_value, @max_value = nil, @options[:maximum]
-          elsif @options[:minimum]
-            @min_value, @max_value = @options[:minimum], nil
-          end
-        end
-
-        default_options :too_short => :too_short, :too_long => :too_long, :wrong_length => :wrong_length
-
-        protected
-          def allow_nil?
-            super(default_message_for(:too_short))
-          end
-
-          def allow_blank?
-            super(default_message_for(:too_short))
-          end
-
-          def less_than_min_length?
-            @min_value.nil? || @min_value <= 1 || bad?(value_for_length(@min_value - 1), default_message_for(:too_short))
-          end
-
-          def exactly_min_length?
-            @min_value.nil? || @min_value <= 0 || good?(value_for_length(@min_value), default_message_for(:too_short))
-          end
-
-          def more_than_max_length?
-            @max_value.nil? || bad?(value_for_length(@max_value + 1), default_message_for(:too_long))
-          end
-
-          def exactly_max_length?
-            @max_value.nil? || @min_value == @max_value || good?(value_for_length(@max_value), default_message_for(:too_long))
-          end
-
-          def value_for_length(value)
-            if @options[:with_kind_of]
-              [@options[:with_kind_of].new] * value
-            else
-              ([@options.fetch(:token, 'x')] * value).join(@options.fetch(:separator, ''))
-            end
-          end
-
-          def interpolation_options
-            { :minimum => @min_value, :maximum => @max_value }
-          end
-
-          # Returns the default message for the validation type.
-          # If user supplied :message, it will return it. Otherwise it will return
-          # wrong_length on :is validation and :too_short or :too_long in the other
-          # types.
-          #
-          def default_message_for(validation_type)
-            return :message if @options[:message]
-            @options.key?(:is) ? :wrong_length : validation_type
-          end
-      end
-
-      # Validates the length of the given attributes. You have also to supply
-      # one of the following options: minimum, maximum, is or within.
-      #
-      # 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>:too_short</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt> when attribute is too short.
-      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.too_short') % range.first</tt>
-      # * <tt>:too_long</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt> when attribute is too long.
-      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.too_long') % range.last</tt>
-      # * <tt>:wrong_length</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt> when attribute is the wrong length.
-      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % range.last</tt>
-      # * <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.wrong_length') % value</tt>
-      #
-      # It also accepts an extra option called :with_kind_of. If you are validating
-      # the size of an association array, you have to specify the kind of the array
-      # being validated. For example, if your post accepts maximum 10 comments, you
-      # can do:
-      #
-      #   should_validate_length_of :comments, :maximum => 10, :with_kind_of => Comment
-      #
-      # Finally, it also accepts :token and :separator, to specify how the
-      # tokenizer should work. For example, if you are splitting the attribute
-      # per word:
-      #
-      #   validates_length_of :essay, :minimum => 100, :tokenizer => lambda {|str| str.scan(/\w+/) }
-      #
-      # You could do this:
-      #
-      #   should_validate_length_of :essay, :minimum => 100, :token => "word", :separator => " "
-      #
-      # == Gotcha
-      #
-      # In Rails 2.3.x, when :message is supplied, it overwrites the messages
-      # supplied in :wrong_length, :too_short and :too_long. However, in earlier
-      # versions, Rails ignores the :message option.
-      #
-      # == Examples
-      #
-      #   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) }
-      #
-      #   should_validate_length_of :password, :within => 6..20
-      #   should_validate_length_of :password, :maximum => 20
-      #   should_validate_length_of :password, :minimum => 6
-      #   should_validate_length_of :age, :is => 18
-      #
-      #   should_validate_length_of :password do |m|
-      #     m.minimum 6
-      #     m.maximum 20
-      #   end
-      #
-      def validate_length_of(*attributes, &block)
-        ValidateLengthOfMatcher.new(*attributes, &block).spec(self)
-      end
-    end
-  end
-end