remarkable_activerecord 3.0.0

data/CHANGELOG

@@ -0,0 +1,47 @@
+# v3.0.0
+
+[ENHANCEMENT] Added more options to associations matcher. Previously it was
+handling just :dependent and :through options. Now it deals with:
+
+  :through, :class_name, :foreign_key, :dependent, :join_table, :uniq,
+  :readonly, :validate, :autosave, :counter_cache, :polymorphic
+
+And they are much smarter! In :join_table and :through cases, they also test if
+the table exists or not. :counter_cache and :foreign_key also checks if the
+column exists or not.
+
+[COMPATIBILITY] Removed callback, have_instance_method and have_class_method
+matchers. They don't lead to a good TDD since you should test they behavior
+and not wether they exist or not.
+
+[COMPATIBILITY] ActiveRecord matches does not pick the instance variable from
+the spec environment. So we should target only rspec versions that supports
+subjects (>= 1.1.12).
+
+Previously, when we are doing this:
+
+   describe Product
+     before(:each){ @product = Product.new(:tangible => true) }
+     should_validate_presence_of :size
+   end
+
+It was validating the @product instance variable. However this might be not
+clear. The right way to do that (with subjects) is:
+
+   describe Product
+     subject{ Product.new(:tangible => true) }
+     should_validate_presence_of :size
+   end
+
+Is also valid to remember that previous versions of Remarkable were overriding
+subject definitions on rspec. This was also fixed.
+
+# v2.x
+
+[ENHANCEMENT] Added associations, allow_mass_assignment, allow_values_for,
+have_column, have_index, have_scope, have_readonly_attributes,
+validate_acceptance_of, validate_associate, validate_confirmation_of,
+validate_exclusion_of, validate_inclusion_of, validate_length_of,
+validate_numericality_of, validate_presence_of and validate_uniqueness_of
+matchers.
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Carlos Brando
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,2 @@
+Remarkable ActiveRecord
+=======================

data/lib/remarkable_activerecord/base.rb

@@ -0,0 +1,238 @@
+module Remarkable
+  module ActiveRecord
+    class Base < Remarkable::Base
+
+      def with_options(opts={})
+        @options.merge!(opts)
+        self
+      end
+
+      protected
+
+        # Checks for the given key in @options, if it exists and it's true,
+        # tests that the value is bad, otherwise tests that the value is good.
+        #
+        # It accepts the key to check for, the value that is used for testing
+        # 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)
+
+          if @options[key]
+            return true if bad?(value, message_key)
+            return false, :not => not_word
+          else
+            return true if good?(value, message_key)
+            return false, :not => ''
+          end
+        end
+
+        # Checks for the given key in @options, if it exists and it's true,
+        # tests that the value is good, otherwise tests that the value is bad.
+        #
+        # It accepts the key to check for, the value that is used for testing
+        # 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)
+
+          if @options[key]
+            return true if good?(value, message_key)
+            return false, :not => ''
+          else
+            return true if bad?(value, message_key)
+            return false, :not => not_word
+          end
+        end
+
+        # Default allow_nil? validation. It accepts the message_key which is
+        # the key which contain the message in @options.
+        #
+        # It also gets an allow_nil message on remarkable.active_record.allow_nil
+        # to be used as default.
+        #
+        def allow_nil?(message_key=:message) #:nodoc:
+          valid, options = assert_good_or_bad_if_key(:allow_nil, nil, message_key)
+
+          unless valid
+            default = Remarkable.t "remarkable.active_record.allow_nil", default_i18n_options.except(:scope).merge(options)
+            return false, options.merge(:default => default)
+          end
+
+          true
+        end
+
+        # Default allow_blank? validation. It accepts the message_key which is
+        # the key which contain the message in @options.
+        #
+        # It also gets an allow_blank message on remarkable.active_record.allow_blank
+        # to be used as default.
+        #
+        def allow_blank?(message_key=:message) #:nodoc:
+          valid, options = assert_good_or_bad_if_key(:allow_blank, '', message_key)
+
+          unless valid
+            default = Remarkable.t "remarkable.active_record.allow_blank", default_i18n_options.except(:scope).merge(options)
+            return false, options.merge(:default => default)
+          end
+
+          true
+        end
+
+        # Shortcut for assert_good_value.
+        #
+        def good?(value, message_sym=:message) #:nodoc:
+          assert_good_value(@subject, @attribute, value, @options[message_sym])
+        end
+
+        # Shortcut for assert_bad_value.
+        #
+        def bad?(value, message_sym=:message) #:nodoc:
+          assert_bad_value(@subject, @attribute, value, @options[message_sym])
+        end
+
+        # Asserts that an Active Record model validates with the passed
+        # <tt>value</tt> by making sure the <tt>error_message_to_avoid</tt> is not
+        # contained within the list of errors for that attribute.
+        #
+        #   assert_good_value(User.new, :email, "user@example.com")
+        #   assert_good_value(User.new, :ssn, "123456789", /length/)
+        #
+        # If a class is passed as the first argument, a new object will be
+        # instantiated before the assertion.  If an instance variable exists with
+        # the same name as the class (underscored), that object will be used
+        # instead.
+        #
+        #   assert_good_value(User, :email, "user@example.com")
+        #
+        #   @product = Product.new(:tangible => false)
+        #   assert_good_value(Product, :price, "0")
+        #
+        def assert_good_value(model, attribute, value, error_message_to_avoid=//) # :nodoc:
+          model.send("#{attribute}=", value)
+
+          return true if model.valid?
+
+          error_message_to_avoid = error_message_from_model(model, attribute, error_message_to_avoid)
+          assert_does_not_contain(model.errors.on(attribute), error_message_to_avoid)
+        end
+
+        # Asserts that an Active Record model invalidates the passed
+        # <tt>value</tt> by making sure the <tt>error_message_to_expect</tt> is
+        # contained within the list of errors for that attribute.
+        #
+        #   assert_bad_value(User.new, :email, "invalid")
+        #   assert_bad_value(User.new, :ssn, "123", /length/)
+        #
+        # If a class is passed as the first argument, a new object will be
+        # instantiated before the assertion.  If an instance variable exists with
+        # the same name as the class (underscored), that object will be used
+        # instead.
+        #
+        #   assert_bad_value(User, :email, "invalid")
+        #
+        #   @product = Product.new(:tangible => true)
+        #   assert_bad_value(Product, :price, "0")
+        #
+        def assert_bad_value(model, attribute, value, error_message_to_expect=:invalid) #:nodoc:
+          model.send("#{attribute}=", value)
+
+          return false if model.valid? || model.errors.on(attribute).blank?
+
+          error_message_to_expect = error_message_from_model(model, attribute, error_message_to_expect)
+          assert_contains(model.errors.on(attribute), error_message_to_expect)
+        end
+
+        # Return the error message to be checked. If the message is not a Symbol
+        # neither a Hash, it returns the own message.
+        #
+        # But the nice thing is that when the message is a Symbol we get the error
+        # messsage from within the model, using already existent structure inside
+        # ActiveRecord.
+        #
+        # This allows a couple things from the user side:
+        #
+        #   1. Specify symbols in their tests:
+        #
+        #     should_allow_values_for(:shirt_size, 'S', 'M', 'L', :message => :inclusion)
+        #
+        #   As we know, allow_values_for searches for a :invalid message. So if we
+        #   were testing a validates_inclusion_of with allow_values_for, previously
+        #   we had to do something like this:
+        #
+        #     should_allow_values_for(:shirt_size, 'S', 'M', 'L', :message => 'not included in list')
+        #
+        #   Now everything gets resumed to a Symbol.
+        #
+        #   2. Do not worry with specs if their are using I18n API properly.
+        #
+        #   As we know, I18n API provides several interpolation options besides
+        #   fallback when creating error messages. If the user changed the message,
+        #   macros would start to pass when they shouldn't.
+        #
+        #   Using the underlying mechanism inside ActiveRecord makes us free from
+        #   all thos errors.
+        #
+        # We replace {{count}} interpolation for 12345 which later is replaced
+        # by a regexp which contains \d+.
+        #
+        def error_message_from_model(model, attribute, message) #:nodoc:
+          if message.is_a? Symbol
+            message = if RAILS_I18N # Rails >= 2.2
+              model.errors.generate_message(attribute, message, :count => '12345')
+            else # Rails <= 2.1
+              ::ActiveRecord::Errors.default_error_messages[message] % '12345'
+            end
+
+            if message =~ /12345/
+              message = Regexp.escape(message)
+              message.gsub!('12345', '\d+')
+              message = /#{message}/
+            end
+          end
+
+          message
+        end
+
+        # Asserts that the given collection does not contain item x. If x is a
+        # regular expression, ensure that none of the elements from the collection
+        # match x.
+        #
+        def assert_does_not_contain(collection, x) #:nodoc:
+          !assert_contains(collection, x)
+        end
+
+        # Changes how collection are interpolated to provide localized names
+        # whenever is possible.
+        #
+        def collection_interpolation
+          described_class = if @subject
+            subject_class
+          elsif @spec
+            @spec.send(:described_class)
+          end
+
+          if RAILS_I18N && described_class.respond_to?(:human_attribute_name) && self.class.matcher_arguments[:collection]
+            options = {}
+
+            collection_name = self.class.matcher_arguments[:collection].to_sym
+            if collection = instance_variable_get("@#{collection_name}")
+              collection.map!{|attr| described_class.human_attribute_name(attr.to_s, :locale => Remarkable.locale).downcase }
+              options[collection_name] = array_to_sentence(collection)
+            end
+
+            object_name = self.class.matcher_arguments[:as]
+            if object = instance_variable_get("@#{object_name}")
+              object = described_class.human_attribute_name(object.to_s, :locale => Remarkable.locale).downcase
+              options[object_name] = object
+            end
+
+            options
+          else
+            super
+          end
+        end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/human_names.rb

@@ -0,0 +1,37 @@
+if defined?(Spec)
+  module Spec
+    module Example
+      module ExampleGroupMethods
+
+        # This allows "describe User" to use the I18n human name of User.
+        #
+        def self.build_description_with_i18n(*args)
+          args.inject("") do |description, arg|
+            arg = if RAILS_I18N && arg.respond_to?(:human_name)
+              arg.human_name(:locale => Remarkable.locale)
+            else
+              arg.to_s
+            end
+
+            description << " " unless (description == "" || arg =~ /^(\s|\.|#)/)
+            description << arg
+          end
+        end
+
+        # This is for rspec <= 1.1.12.
+        #
+        def self.description_text(*args)
+          self.build_description_with_i18n(*args)
+        end
+
+        # This is for rspec >= 1.2.0.
+        #
+        def build_description_from(*args)
+          text = ExampleGroupMethods.build_description_with_i18n(*args)
+          text == "" ? nil : text
+        end
+
+      end
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/allow_mass_assignment_of_matcher.rb

@@ -0,0 +1,34 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class AllowMassAssignmentOfMatcher < Remarkable::ActiveRecord::Base
+        arguments :collection => :attributes, :as => :attribute
+
+        collection_assertions :is_protected?, :is_accessible?
+
+        protected
+
+          def is_protected?
+            protected = subject_class.protected_attributes || []
+            protected.empty? || !protected.include?(@attribute.to_s)
+          end
+
+          def is_accessible?
+            accessible = subject_class.accessible_attributes || []
+            accessible.empty? || accessible.include?(@attribute.to_s)
+          end
+      end
+
+      # Ensures that the attribute can be set on mass update.
+      #
+      # == Examples
+      #
+      #   should_allow_mass_assignment_of :email, :name
+      #   it { should allow_mass_assignment_of(:email, :name) }
+      #
+      def allow_mass_assignment_of(*attributes)
+        AllowMassAssignmentOfMatcher.new(*attributes).spec(self)
+      end
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/allow_values_for_matcher.rb

@@ -0,0 +1,94 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class AllowValuesForMatcher < Remarkable::ActiveRecord::Base
+        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 => :invalid
+
+        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?
+            valid_values.each do |value|
+              return false, :value => value.inspect unless good?(value)
+            end
+            true
+          end
+
+          def is_invalid?
+            invalid_values.each do |value|
+              return false, :value => value.inspect unless bad?(value)
+            end
+            true
+          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 => @options[:in].map(&:inspect).to_sentence }
+            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.
+      #
+      # Note: this matcher accepts at once just one attribute to test.
+      # Note: this matcher is also aliased as "validate_format_of".
+      #
+      # == 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>
+      #
+      # == Examples
+      #
+      #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
+      #   should_not_allow_values_for :isbn, "bad 1", "bad 2"
+      #
+      #   it { should allow_values_for(:isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0") }
+      #   it { should_not allow_values_for(:isbn, "bad 1", "bad 2") }
+      #
+      def allow_values_for(attribute, *args)
+        options = args.extract_options!
+        AllowValuesForMatcher.new(attribute, options.merge!(:in => args)).spec(self)
+      end
+      alias :validate_format_of :allow_values_for
+
+    end
+  end
+end