carlosbrando-remarkable 2.2.9 → 2.2.10

data/lib/remarkable.rb

@@ -2,7 +2,7 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module Remarkable
-  VERSION = '2.2.9'
+  VERSION = '2.2.10'
 end
 
 if ENV['RAILS_ENV'] == 'test' && defined?(Spec)

data/lib/remarkable/active_record/README.markdown

@@ -297,11 +297,13 @@ Options:
 * :in - A synonym(or alias) for :within.
 * :allow_nil - when supplied, validates if it allows nil or not.
 * :allow_blank - when supplied, validates if it allows blank or not.
-* :short_message - value the test expects to find in errors.on(:attribute).
+* :too_short - value the test expects to find in errors.on(:attribute) when attribute is too short.
   Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.too_short') % range.first
-* :long_message - value the test expects to find in errors.on(:attribute).
+* :too_long - value the test expects to find in errors.on(:attribute) when attribute is too long.
   Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.too_long') % range.last
-* :message - value the test expects to find in errors.on(:attribute) only when :minimum, :maximum or :is is given.
+* :wrong_length - value the test expects to find in errors.on(:attribute) when attribute is the wrong length.
+  Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.wrong_length') % range.last
+* :message - value the test expects to find in errors.on(:attribute). When supplied overwrites :too_short, :too_long and :wrong_length.
   Regexp, string or symbol. Default = I18n.translate('activerecord.errors.messages.wrong_length') % value
 
 <pre><code>  should_validate_length_of :password, :within => 6..20

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

@@ -5,21 +5,19 @@ module Remarkable # :nodoc:
         include Remarkable::ActiveRecord::Helpers
 
         arguments :behavior, :range, :attributes
-        optional  :minimum, :maximum, :short_message, :long_message
+        optional  :message, :minimum, :maximum, :too_short, :too_long, :wrong_length
 
         assertions :less_than_min_length?, :exactly_min_length?, :allow_nil?,
                    :more_than_max_length?, :exactly_max_length?, :allow_blank?
 
-        # 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
+        def short_message(message)
+          warn "[DEPRECATION] :short_message is deprecated for validate_length_of, please use :too_short instead"
+          too_short(message)
+        end
+
+        def long_message(message)
+          warn "[DEPRECATION] :long_message is deprecated for validate_length_of, please use :too_long instead"
+          too_long(message)
         end
 
         def within(range)
@@ -51,35 +49,26 @@ module Remarkable # :nodoc:
         private
 
         def default_options
-          if @behavior == :is
-            { :short_message => :wrong_length, :long_message => :wrong_length }
-          else
-            { :short_message => :too_short, :long_message => :too_long }
-          end
+          { :too_long => :too_long, :too_short => :too_short, :wrong_length => :wrong_length }
         end
 
-        # Reassign messages properly
-        def after_initialize
+        def before_assert
           # Set the values, for example:
           # send(:within, 0..10)
           send(@behavior, @range)
-
-          message(@options.delete(:message)) if @options[:message]
-          long_message(@options[:long_message])
-          short_message(@options[:short_message])
         end
 
         def allow_nil?
-          super(:short_message)
+          super(default_message_for(:too_short))
         end
 
         def allow_blank?
-          super(:short_message)
+          super(default_message_for(:too_short))
         end
 
         def less_than_min_length?
           return true if @behavior == :maximum || @options[:minimum] <= 1
-          return true if bad?(value_for_length(@options[:minimum] - 1), :short_message)
+          return true if bad?(value_for_length(@options[:minimum] - 1), default_message_for(:too_short))
 
           @missing = "allow #{@attribute} to be less than #{@options[:minimum]} chars long"
           return false
@@ -87,7 +76,7 @@ module Remarkable # :nodoc:
 
         def exactly_min_length?
           return true if @behavior == :maximum || @options[:minimum] <= 0
-          return true if good?(value_for_length(@options[:minimum]), :short_message)
+          return true if good?(value_for_length(@options[:minimum]), default_message_for(:too_short))
 
           @missing = "not allow #{@attribute} to be exactly #{@options[:minimum]} chars long"
           return false
@@ -95,7 +84,7 @@ module Remarkable # :nodoc:
 
         def more_than_max_length?
           return true if @behavior == :minimum
-          return true if bad?(value_for_length(@options[:maximum] + 1), :long_message)
+          return true if bad?(value_for_length(@options[:maximum] + 1), default_message_for(:too_long))
 
           @missing = "allow #{@attribute} to be more than #{@options[:maximum]} chars long"
           return false
@@ -103,7 +92,7 @@ module Remarkable # :nodoc:
 
         def exactly_max_length?
           return true if @behavior == :minimum || @options[:minimum] == @options[:maximum]
-          return true if good?(value_for_length(@options[:maximum]), :long_message)
+          return true if good?(value_for_length(@options[:maximum]), default_message_for(:too_long))
 
           @missing = "not allow #{@attribute} to be exactly #{@options[:maximum]} chars long"
           return false
@@ -130,6 +119,16 @@ module Remarkable # :nodoc:
         def value_for_length(value)
           "x" * 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
@@ -150,11 +149,13 @@ module Remarkable # :nodoc:
       # * <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>.
+      # * <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>:long_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</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>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt> only when :minimum, :maximum or :is is given.
+      # * <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>. When supplied overwrites :too_short, :too_long and :wrong_length.
       #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % value</tt>
       #
       # Example:

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

@@ -62,14 +62,26 @@ module Remarkable # :nodoc:
           assert_bad_or_good_if_key(:only_integer, valid_value_for_test.to_f, message, default_message_for(:number))
         end
 
+        # In ActiveRecord, when we supply :even, does not matter the value, it
+        # considers that should odd values should be accepted.
+        #
         def allow_even?
-          message = "allow even values for #{@attribute}"
-          assert_bad_or_good_if_key(:even, valid_value_for_test + 1, message, default_message_for(:even))
+          return true unless @options[:even]
+          return true if bad?(even_valid_value_for_test + 1, default_message_for(:even))
+
+          message = "allow non-even values for #{@attribute}"
+          return false
         end
 
+        # In ActiveRecord, when we supply :odd, does not matter the value, it
+        # considers that should odd values should be accepted.
+        #
         def allow_odd?
-          message = "allow odd values for #{@attribute}"
-          assert_bad_or_good_if_key(:odd, even_valid_value_for_test, message, default_message_for(:odd))
+          return true unless @options[:odd]
+          return true if bad?(even_valid_value_for_test, default_message_for(:odd))
+
+          message = "allow non-odd values for #{@attribute}"
+          return false
         end
 
         def equal_to?(key, add = 0)

data/lib/remarkable/controller/README.markdown

@@ -8,20 +8,20 @@ Macro that creates a test asserting that the controller assigned to each of the
 
 Options:
 
-    * :class - The expected class of the instance variable being checked.
-    * :equals - A string or a proc which is evaluated and compared with the instance variable being checked.
+    * :with - A string or a proc which is evaluated and compared with the instance variable being checked.
+    * :with_kind_of - The expected class of the instance variable being checked.
 
 Example:
 
 <pre><code>  should_assign_to :user, :posts
-  should_assign_to :user, :class => User
-  should_assign_to :user, :equals => proc { @user }
+  should_assign_to :user, :with_kind_of => User
+  should_assign_to :user, :with => proc { @user }
   should_assign_to(:user){ @user }
   should_not_assign_to :user, :posts
 
   it { should assign_to(:user, :posts) }
-  it { should assign_to(:user, :class => User) }
-  it { should assign_to(:user, :equals => @user) }
+  it { should assign_to(:user, :with_kind_of => User) }
+  it { should assign_to(:user, :with => @user) }
   it { should_not assign_to(:user, :posts) }</code></pre>
 
 h2. filter_params

data/lib/remarkable/controller/macros/assign_matcher.rb

@@ -3,6 +3,8 @@ module Remarkable # :nodoc:
     module Matchers # :nodoc:
       class AssignMatcher < Remarkable::Matcher::Base
         include Remarkable::Controller::Helpers
+
+        optional :with, :with_kind_of
         
         def initialize(*names, &block)
           @options          = names.extract_options!
@@ -10,6 +12,11 @@ module Remarkable # :nodoc:
           @options[:equals] = block if block_given?
 
           warn "[DEPRECATION] Strings given in :equals to should_assign_to won't be evaluated anymore. You can give procs or use blocks instead." if @options[:equals].is_a?(String)
+          warn "[DEPRECATION] :equals option is deprecated in should_assign_to. Please give :with instead."        if @options[:equals]
+          warn "[DEPRECATION] :class option is deprecated in should_assign_to. Please give :with_kind_of instead." if @options[:class]
+
+          @options[:with]         ||= @options.delete(:equals)
+          @options[:with_kind_of] ||= @options.delete(:class)
         end
 
         def matches?(subject)
@@ -25,8 +32,8 @@ module Remarkable # :nodoc:
 
         def description
           description = "assign @#{@names.to_sentence}"
-          description << " as class #{@options[:class]}" if @options[:class]
-          description << " which is equal to #{@options[:equals]}" if @options[:equals]
+          description << " as class #{@options[:with_kind_of]}" if @options[:with_kind_of]
+          description << " which is equal to #{@options[:with]}" if @options[:with]
           description
         end
         
@@ -49,22 +56,22 @@ module Remarkable # :nodoc:
         end
         
         def is_kind_of?
-          return true unless @options[:class]
-          return true if @assigned_value.kind_of?(@options[:class])
+          return true unless @options[:with_kind_of]
+          return true if @assigned_value.kind_of?(@options[:with_kind_of])
           
-          @missing = "@#{@name} is not a kind of #{@options[:class]}"
+          @missing = "@#{@name} is not a kind of #{@options[:with_kind_of]}"
           return false
         end
         
         def is_equals_expected_value?
-          return true unless @options[:equals]
+          return true unless @options[:with]
 
-          expected_value = if @options[:equals].is_a?(String)
-            @spec.instance_eval(@options[:equals]) rescue @options[:equals]
-          elsif @options[:equals].is_a?(Proc)
-            @spec.instance_eval &@options[:equals]
+          expected_value = if @options[:with].is_a?(String)
+            @spec.instance_eval(@options[:with]) rescue @options[:with]
+          elsif @options[:with].is_a?(Proc)
+            @spec.instance_eval &@options[:with]
           else
-            @options[:equals]
+            @options[:with]
           end
           return true if @assigned_value == expected_value
 
@@ -74,8 +81,8 @@ module Remarkable # :nodoc:
         
         def expectation
           expectation = "assign @#{@name}"
-          expectation << " as class #{@options[:class]}" if @options[:class]
-          expectation << " which is equal to #{@options[:equals].inspect}" if @options[:equals] && !@options[:equals].is_a?(Proc)
+          expectation << " as class #{@options[:with_kind_of]}" if @options[:with_kind_of]
+          expectation << " which is equal to #{@options[:with].inspect}" if @options[:with] && !@options[:with].is_a?(Proc)
           expectation
         end
 

data/remarkable.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{remarkable}
-  s.version = "2.2.9"
+  s.version = "2.2.10"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Carlos Brando", "Jos\303\251 Valim", "Diego Carrion"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: carlosbrando-remarkable
 version: !ruby/object:Gem::Version 
-  version: 2.2.9
+  version: 2.2.10
 platform: ruby
 authors: 
 - Carlos Brando