remarkable_activemodel 4.0.0.alpha1

data/CHANGELOG

@@ -0,0 +1,147 @@
+* allow_values_for checks for any message unless otherwise given [#90]
+
+* 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]
+
+* Deprecated validate_format_of. It does not have the same API as the respective
+  ActiveModel macro, raising questions frequentely about its usage [#76]
+
+* allow_mass_assignment_of when called without arguments checks if any mass
+  assignment is possible [#80]
+
+* Add :table_name option to have_index (thanks to Lawrence Pit) [#79]
+
+* Allow default subject attributes to be given [#74]
+  You can even mix with a fixture replacement tool and still use quick subjects:
+
+    describe Post
+      # Fixjour example
+      subject_attributes { valid_post_attributes }
+
+      describe :published => true do
+        should_validate_presence_of :published_at
+      end
+    end
+
+* Bug fix when a symbol is given has join table to habtm association [#75]
+
+* Association matchers now searches in the right database for tables [#73]
+
+* validate_length_of accepts :with_kind_of to enable it to work with associations [#69]
+  In your Post specs now you can write:
+
+    should_validate_length_of :comments, :maximum => 10, :with_kind_of => Comment
+
+# v3.1
+
+* Allow validate_presence_of to work with associations [#63]
+
+* Allow validate_uniqueness_of to work when scopes are not stringfiable values.
+  You can now give timestamps, datetime, date and boolean as scopes [#60]
+
+* Allow subjects to be overwriten quickly (quick subjects):
+
+    describe Post
+      should_validate_presente_of :title
+ 
+      describe :published => true do
+        should_validate_presence_of :published_at
+      end
+    end
+ 
+  Is the same as:
+
+    describe Post
+      should_validate_presente_of :title
+ 
+      describe "when published is true" do
+        subject { Post.new(:published => true) }
+        should_validate_presence_of :published_at
+      end
+    end
+
+  And the string can be also localized using I18n [#57]
+
+[COMPATIBILITY] validate_associated no longer accepts a block to confgure the
+builder:
+
+    should_validate_associated(:tasks){ |p| p.tasks.build(:captcha => 'i_am_a_robot') }
+
+The right way to do this is by giving an option called builder and a proc:
+
+    should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_robot') }
+
+* validate_uniqueness_of and accept_nested_attributes_for now use the new
+  interpolation option {{sentence}} [#58]
+
+* Added accept_nested_attributes_for matcher [#39]
+
+* Added have_default_scope matcher [#38]
+
+* Allow :conditions, :include, :joins, :limit, :offset, :order, :select, :readonly,
+  :group, :having, :from, :lock as quick accessors to have_scope matcher
+
+* Allow all kind of objects to be sent to have_scope (including datetimes, arrays,
+  booleans and nil) (thanks to Szymon Nowak and Nolan Eakins) [#53]
+
+* Added support to sql options in association_matcher: select, conditions, include,
+  group, having, order, limit and offset, plus finder_sql and counter_sql. [#48]
+
+* :source and :source_type are now supported by association matcher [#47]
+
+* validate_inclusion_of became smarter since it now tests invalid values too [#36]
+
+* Fixed three bugs in validate_uniqueness_of matcher [#42] [#40] [#37]
+
+# v3.0
+
+* 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] ActiveModel 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
+
+* Added associations, allow_mass_assignment, allow_values_for, have_column,
+have_index, have_scope, have_readonly_attributes, validate_acceptance_of,
+validate_associated, 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,74 @@
+= Remarkable ActiveModel
+
+Remarkable ActiveModel is a collection of matchers to ActiveModel. Why use
+Remarkable?
+
+* Matchers for all ActiveModel validations, with support to all options. The only
+  exceptions are validate_format_of (which should be invoked as allow_values_for)
+  and the :on option;
+
+  This means you can test your validations any model that mixes-in ActiveModel::Validations
+
+* Tests and more tests. We have a huge tests suite ready to run and tested in
+  ActiveModel 3.0.0;
+
+* Great documentation;
+
+* I18n.
+
+Upcoming features:
+* Matchers wrapping ActiveModel::Lint for testing ActiveModel API compliance.
+  This means your custom models using RESTClient, for example, can play nice with
+  Rails.
+
+* Matchers testing ActiveModel::Serialization
+  This allows you to test for compliance if you are using special serialization
+  methods, or require the use of Presenters in your application.
+
+
+== Examples
+
+All Remarkable macros can be accessed in two different ways. For those who prefer the Shoulda style, let’s look at some model tests:
+
+  describe Post do
+    should_validate_presence_of :body
+    should_validate_presence_of :title
+  end
+
+For those who likes more the Rspec way can simply do:
+
+  describe Post do
+    it { should validate_presence_of(:body) }
+    it { should validate_presence_of(:title) }
+  end
+
+== I18n
+
+All matchers come with I18n support. If you want to translate your matchers,
+grab make a copy of locale/en.yml and start to translate it.
+
+Then add your new locale file to Remarkable:
+
+  Remarkable.add_locale 'path/to/my_locale.yml'
+
+And then:
+
+  Remarkable.locale = :my_locale
+
+== Using it outside Rails
+
+If you want to use Remarkable ActiveModel outside Rails, you have to remember
+a few things:
+
+  1. Internationalization is powered by the I18n gem. If you are using it with Rails,
+     it will use the built in gem, otherwise you will have to install the gem by hand:
+
+        gem install i18n
+
+  2. Include the matchers. Remarkable Rails gem is the responsable to add
+     ActiveModel matchers to rspec. If you are not using it, you have to do:
+
+        Remarkable.include_matchers!(Remarkable::ActiveModel, Rspec::Core::ExampleGroup)
+
+     This will make ActiveModel matchers available in all rspec example groups.
+

data/lib/remarkable_activemodel.rb

@@ -0,0 +1,28 @@
+# Load Remarkable
+unless Object.const_defined?('Remarkable')
+  begin
+    require 'remarkable'
+  rescue LoadError
+    require 'rubygems'
+    gem 'remarkable'
+    require 'remarkable'
+  end
+end
+
+# Load Remarkable ActiveModel files
+dir = File.dirname(__FILE__)
+require File.join(dir, 'remarkable_activemodel', 'base')
+
+# Add locale
+Remarkable.add_locale File.join(dir, '..', 'locale', 'en.yml')
+
+# Add matchers
+Dir[File.join(dir, 'remarkable_activemodel', 'matchers', '*.rb')].each do |file|
+  require file
+end
+
+# By default, ActiveModel matchers are not included in any example group.
+# The responsibility for this is RemarkableRails. If you are using ActiveModel
+# without Rails, put the line below in your spec_helper to include ActiveModel
+# matchers into rspec globally.
+# Remarkable.include_matchers!(Remarkable::ActiveModel, Rspec::Example::ExampleGroup)

data/lib/remarkable_activemodel/base.rb

@@ -0,0 +1,252 @@
+module Remarkable
+  module ActiveModel
+    class Base < Remarkable::Base
+      I18N_COLLECTION = [ :attributes, :associations ]
+
+      # Provides a way to send options to all ActiveModel matchers.
+      #
+      #   validates_presence_of(:name).with_options(:allow_nil => false)
+      #
+      # Is equivalent to:
+      #
+      #   validates_presence_of(:name, :allow_nil => false)
+      #
+      def with_options(opts={})
+        @options.merge!(opts)
+        self
+      end
+
+      protected
+
+        # Overwrite subject_name to provide I18n.
+        #
+        def subject_name
+          nil unless @subject
+          if subject_class.respond_to?(:model_name)
+            subject_class.model_name.human(:locale => Remarkable.locale)
+          else
+            subject_class.name
+          end
+        end
+
+        # 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 positive? unless @options.key?(key)
+
+          if @options[key]
+            return bad?(value, message_key), :not => not_word
+          else
+            return good?(value, message_key), :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 positive? unless @options.key?(key)
+
+          if @options[key]
+            return good?(value, message_key), :not => ''
+          else
+            return bad?(value, message_key), :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_model.allow_nil
+        # to be used as default.
+        #
+        def allow_nil?(message_key=:message) #:nodoc:
+          assert_good_or_bad_if_key(:allow_nil, nil, message_key)
+        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_model.allow_blank
+        # to be used as default.
+        #
+        def allow_blank?(message_key=:message) #:nodoc:
+          assert_good_or_bad_if_key(:allow_blank, '', message_key)
+        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[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[attribute].blank?
+
+          error_message_to_expect = error_message_from_model(model, attribute, error_message_to_expect)
+          assert_contains(model.errors[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
+        # ActiveModel.
+        #
+        # This allows a couple things from the user side:
+        #
+        #   1. Rspecify 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 ActiveModel 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
+              if ::ActiveModel.const_defined?(:Error)
+                ::ActiveModel::Error.new(model, attribute, message, :count => '12345').to_s
+              else
+                model.errors.generate_message(attribute, message, :count => '12345')
+              end
+            else # Rails <= 2.1
+              ::ActiveModel::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 #:nodoc:
+          described_class = if @subject
+            subject_class
+          elsif @spec
+            @spec.send(:described_class)
+          end
+
+          if i18n_collection? && described_class.respond_to?(:human_attribute_name)
+            options = {}
+
+            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
+              end
+              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
+
+        # 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
+  end
+end