remarkable_activerecord 3.1.7 → 3.1.8

data/CHANGELOG

@@ -1,3 +1,8 @@
+* Allow booleans to be given to validate_inclusion_of [#89]
+
+* Allow allow_values_for and allow_mass_assignment_of matchers to be executed in
+  the negative form by including Remarkable::Negative module [#85]
+
 * Ensure quick subject bypass protected attributes [#87]
 
 * Added :token and :separator to deal with :tokenizer in validates_length_of [#77]

data/lib/remarkable_activerecord/base.rb

@@ -1,6 +1,6 @@
 module Remarkable
   module ActiveRecord
-    class Base < Remarkable::Base
+    class Base < Remarkable::Base
       I18N_COLLECTION = [ :attributes, :associations ]
 
       # Provides a way to send options to all ActiveRecord matchers.
@@ -25,14 +25,12 @@ module Remarkable
         # and an @options key where the message to search for is.
         #
         def assert_bad_or_good_if_key(key, value, message_key=:message) #:nodoc:
-          return true unless @options.key?(key)
+          return positive? unless @options.key?(key)
 
           if @options[key]
-            return true if bad?(value, message_key)
-            return false, :not => not_word
+            return bad?(value, message_key), :not => not_word
           else
-            return true if good?(value, message_key)
-            return false, :not => ''
+            return good?(value, message_key), :not => ''
           end
         end
 
@@ -43,14 +41,12 @@ module Remarkable
         # and an @options key where the message to search for is.
         #
         def assert_good_or_bad_if_key(key, value, message_key=:message) #:nodoc:
-          return true unless @options.key?(key)
+          return positive? unless @options.key?(key)
 
           if @options[key]
-            return true if good?(value, message_key)
-            return false, :not => ''
+            return good?(value, message_key), :not => ''
           else
-            return true if bad?(value, message_key)
-            return false, :not => not_word
+            return bad?(value, message_key), :not => not_word
           end
         end
 
@@ -212,8 +208,8 @@ module Remarkable
 
             collection_name = self.class.matcher_arguments[:collection].to_sym
             if collection = instance_variable_get("@#{collection_name}")
-              collection = collection.map do |attr|
-                described_class.human_attribute_name(attr.to_s, :locale => Remarkable.locale).downcase
+              collection = collection.map do |attr|
+                described_class.human_attribute_name(attr.to_s, :locale => Remarkable.locale).downcase
               end
               options[collection_name] = array_to_sentence(collection)
             end
@@ -228,12 +224,12 @@ module Remarkable
           else
             super
           end
-        end
-
-        # Returns true if the given collection should be translated.
-        #
-        def i18n_collection? #:nodoc:
-          RAILS_I18N && I18N_COLLECTION.include?(self.class.matcher_arguments[:collection])
+        end
+
+        # Returns true if the given collection should be translated.
+        #
+        def i18n_collection? #:nodoc:
+          RAILS_I18N && I18N_COLLECTION.include?(self.class.matcher_arguments[:collection])
         end
 
     end

data/lib/remarkable_activerecord/matchers/allow_mass_assignment_of_matcher.rb

@@ -1,32 +1,40 @@
 module Remarkable
   module ActiveRecord
     module Matchers
-      class AllowMassAssignmentOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+      class AllowMassAssignmentOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        include Remarkable::Negative
         arguments :collection => :attributes, :as => :attribute
 
         assertion :allows?
-        collection_assertions :is_protected?, :is_accessible?
+        collection_assertions :is_accessible?, :is_protected?
 
         protected
 
           # If no attribute is given, check if no attribute is being protected,
           # otherwise it fails.
           #
-          def allows?
-            !@attributes.empty? || protected_attributes.empty?
+          def allows?
+            return positive? unless @attributes.empty?
+            protected_attributes.empty?
           end
 
-          def is_protected?
-            protected_attributes.empty? || !protected_attributes.include?(@attribute.to_s)
+          def is_protected?
+            return positive? if protected_attributes.empty?
+            !protected_attributes.include?(@attribute.to_s)
           end
 
-          def is_accessible?
-            accessible_attributes.empty? || accessible_attributes.include?(@attribute.to_s)
+          def is_accessible?
+            return positive? if accessible_attributes.empty?
+            accessible_attributes.include?(@attribute.to_s)
           end
 
           def interpolation_options
-            if @subject
-              { :protected_attributes => array_to_sentence(protected_attributes.to_a, false, '[]') }
+            if @subject
+              if positive?
+                { :protected_attributes => array_to_sentence(protected_attributes.to_a, false, '[]') }
+              else
+                { :accessible_attributes => array_to_sentence(accessible_attributes.to_a, false, '[]') }
+              end
             else
               {}
             end
@@ -43,20 +51,7 @@ module Remarkable
           end
       end
 
-      # Ensures that the attribute can be set on mass update.
-      #
-      # Beware that when used in the negative form, this matcher fails if any of
-      # the values fail. For example, let's assume we have a accessible and a
-      # protected attribute called :accessible and :protected. The following
-      # assertion WILL pass:
-      #
-      #   should_not_allow_mass_assignment_of :protected, :accessible
-      #
-      # If you want to assert that all values fail, you have to do:
-      #
-      #   %w(first_protected second_protected).each do |protected|
-      #     should_not_allow_mass_assignment_of protected
-      #   end
+      # Ensures that the attribute can be set on mass update.
       #
       # == Examples
       #

data/lib/remarkable_activerecord/matchers/allow_values_for_matcher.rb

@@ -1,7 +1,8 @@
 module Remarkable
   module ActiveRecord
     module Matchers
-      class AllowValuesForMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+      class AllowValuesForMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        include Remarkable::Negative
         arguments :collection => :attributes, :as => :attribute
 
         optional :message
@@ -27,18 +28,16 @@ module Remarkable
 
         protected
 
-          def is_valid?
-            valid_values.each do |value|
-              return false, :value => value.inspect unless good?(value)
+          def is_valid?
+            assert_collection :value, valid_values do |value|
+              good?(value)
             end
-            true
           end
 
-          def is_invalid?
-            invalid_values.each do |value|
-              return false, :value => value.inspect unless bad?(value)
+          def is_invalid?
+            assert_collection :value, invalid_values do |value|
+              bad?(value)
             end
-            true
           end
 
           def valid_values
@@ -63,19 +62,7 @@ module Remarkable
 
       end
 
-      # Ensures that the attribute can be set to the given values.
-      #
-      # Beware that when used in the negative form, this matcher fails if any of
-      # the values fail. For example, let's assume we have a valid and invalid
-      # value called "valid" and "invalid". The following assertion WILL pass:
-      #
-      #   should_not_allow_values_for :attribute, "valid", "invalid"
-      #
-      # If you want to assert that all values fail, you have to do:
-      #
-      #   %w(first_invalid second_invalid).each do |invalid|
-      #     should_not_allow_values_for invalid
-      #   end
+      # Ensures that the attribute can be set to the given values.
       #
       # == Options
       #

data/lib/remarkable_activerecord/matchers/validate_exclusion_of_matcher.rb

@@ -4,6 +4,8 @@ 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
 
@@ -12,10 +14,9 @@ module Remarkable
           def valid_values
             if @in_range
               [ @options[:in].first - 1, @options[:in].last + 1 ]
-            elsif @options[:in].empty?
-              []
-            else
-              [ @options[:in].map(&:to_s).max.to_s.next ]
+            else
+              value = @options[:in].select{ |i| i.is_a?(String) }.max
+              value ? [ value.next ] : []
             end
           end
 

data/lib/remarkable_activerecord/matchers/validate_inclusion_of_matcher.rb

@@ -4,8 +4,10 @@ module Remarkable
   module ActiveRecord
     module Matchers
       class ValidateInclusionOfMatcher < AllowValuesForMatcher #:nodoc:
-
-        default_options :message => :inclusion
+        # Don't allow it to behave in the negative way.
+        undef_method :does_not_match?
+
+        default_options :message => :inclusion
 
         protected
 
@@ -16,10 +18,9 @@ module Remarkable
           def invalid_values
             if @in_range
               [ @options[:in].first - 1, @options[:in].last + 1 ]
-            elsif @options[:in].empty?
-              []
-            else
-              [ @options[:in].map(&:to_s).max.to_s.next ]
+            else
+              value = @options[:in].select{ |i| i.is_a?(String) }.max
+              value ? [ value.next ] : []
             end
           end
 

data/locale/en.yml

@@ -7,7 +7,7 @@ en:
         connector: " and "
       expectations:
         allow_nil: "{{subject_name}} to {{not}}allow nil values for {{attribute}}"
-        allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
+        allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
       optionals:
         allow_nil:
           positive: "allowing nil values"
@@ -37,14 +37,18 @@ en:
       allow_values_for:
         description: "allow {{in}} as values for {{attributes}}"
         expectations:
-          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
 
       allow_mass_assignment_of:
         description: "allow mass assignment of {{attributes}}"
         expectations:
           allows: "{{subject_name}} to allow mass assignment ({{subject_name}} is protecting {{protected_attributes}})"
           is_protected: "{{subject_name}} to allow mass assignment of {{attribute}} ({{subject_name}} is protecting {{attribute}})"
-          is_accessible: "{{subject_name}} to allow mass assignment of {{attribute}} ({{subject_name}} has not made {{attribute}} accessible)"
+          is_accessible: "{{subject_name}} to allow mass assignment of {{attribute}} ({{subject_name}} has not made {{attribute}} accessible)"
+        negative_expectations:
+          allows: "{{subject_name}} to allow mass assignment ({{subject_name}} made {{accessible_attributes}} accessible)"
+          is_protected: "{{subject_name}} to allow mass assignment of {{attribute}} ({{subject_name}} is not protecting {{attribute}})"
+          is_accessible: "{{subject_name}} to allow mass assignment of {{attribute}} ({{subject_name}} has made {{attribute}} accessible)"
 
       association:
         belongs_to: belong to

data/spec/allow_mass_assignment_of_matcher_spec.rb

@@ -75,7 +75,24 @@ describe 'allow_mass_assignment_of' do
     should_allow_mass_assignment_of :title, :category
 
     should_not_allow_mass_assignment_of :another
-    should_not_allow_mass_assignment_of :title, :another
+  end
+
+  describe 'failures' do
+    it "should fail if not all attributes are accessible on should not" do
+      define_and_validate(:accessible => true)
+
+      lambda {
+        should_not allow_mass_assignment_of :title, :another
+      }.should raise_error(Spec::Expectations::ExpectationNotMetError, /Product has made title accessible/)
+    end
+
+    it "should fail if accessible when protecting" do
+      define_and_validate(:accessible => true)
+
+      lambda {
+        should_not allow_mass_assignment_of
+      }.should raise_error(Spec::Expectations::ExpectationNotMetError, /Product made category and title accessible/)
+    end
   end
 end
 

data/spec/allow_values_for_matcher_spec.rb

@@ -56,6 +56,16 @@ describe 'allow_values_for' do
       it { should validate_format_of(:title, 'X') }
       should_not_validate_format_of :title, 'A'
     end
+  end
+
+  describe 'failures' do
+    it "should fail if any of the values are valid on invalid cases" do
+      define_and_validate(:with => /X|Y|Z/)
+
+      lambda {
+        should_not allow_values_for :title, 'A', 'X', 'B'
+      }.should raise_error(Spec::Expectations::ExpectationNotMetError, /Did not expect Product to be valid/)
+    end
   end
 end
 

data/spec/validate_inclusion_of_matcher_spec.rb

@@ -49,6 +49,9 @@ describe 'validate_inclusion_of' do
     it { should_not define_and_validate(:in => ['X', 'Y', 'Z']).in('X', 'Y') }
     it { should_not define_and_validate(:in => ['X', 'Y', 'Z']).in('A') }
 
+    it { should define_and_validate(:in => [true, false]).in(true, false) }
+    it { should_not define_and_validate(:in => [true, false]).in('A') }
+
     it { should define_and_validate(:in => 2..3).in(2..3) }
     it { should define_and_validate(:in => 2..20).in(2..20) }
     it { should_not define_and_validate(:in => 2..20).in(1..20) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: remarkable_activerecord
 version: !ruby/object:Gem::Version 
-  version: 3.1.7
+  version: 3.1.8
 platform: ruby
 authors: 
 - Carlos Brando
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-05 00:00:00 +02:00
+date: 2009-07-16 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,7 +32,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.1.7
+        version: 3.1.8
     version: 
 description: "Remarkable ActiveRecord: collection of matchers and macros with I18n for ActiveRecord"
 email: