specstar-remarkable 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d716a190c66558bee739a9a0a68ff8a93829b8d
+  data.tar.gz: 63c5942765d25ca67c72e18a4c90d64fb3aba79c
+SHA512:
+  metadata.gz: c448f82b4c5404739ac5acd9ff763575a4ccae4652121e94c03567457acfaa897f41f9a67e1e427ef3d9e8f0c78dec2ab8a6ccf65e52cb3320a11d75207bdddf
+  data.tar.gz: 4891bb7c7f963b8462505ee4eeb4cf5a008cc6b6803feea4e7d76af13d677b192ba95b27a6f71410c1a34c38e65e05b6bf95bf17c11e6198a48edb638181362e

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
+  ActiveRecord 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] 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
+
+* 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,103 @@
+= Remarkable ActiveRecord
+
+Remarkable ActiveRecord is a collection of matchers to ActiveRecord. Why use
+Remarkable?
+
+* Matchers for all ActiveRecord 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;
+
+* Matchers for all ActiveRecord associations. The only one which supports all
+  these options:
+
+    :through, :source, :source_type, :class_name, :foreign_key, :dependent,
+    :join_table, :uniq, :readonly, :validate, :autosave, :counter_cache, :polymorphic
+
+  Plus Arel scopes:
+
+    :select, :where, :include, :group, :having, :order, :limit, :offset
+
+  Besides in Remarkable 3.0 matchers became much smarter. Whenever :join_table
+  or :through is given as option, it checks if the given table exists. Whenever
+  :foreign_key or :counter_cache is given, it checks if the given column exists;
+
+* Tests and more tests. We have a huge tests suite ready to run and tested in
+  ActiveRecord 2.1.2, 2.2.2 and 2.3.2;
+
+* Great documentation;
+
+* I18n.
+
+== Installation
+
+  sudo gem install remarkable_activerecord --pre
+
+Add this to your Gemfile:
+
+  group :test do
+     gem 'remarkable_activerecord', '>=4.0.0.alpha2'
+  end
+
+Drop this into your spec/spec_helper.rb or spec/support/remarkable.rb file:
+
+  require 'remarkable/active_record'
+
+This will also automatically load remarkable/active_model and add those matchers as well.
+
+== 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_belong_to :user
+    should_have_many :comments
+    should_have_and_belong_to_many :tags
+
+    should_validate_presence_of :body
+    should_validate_presence_of :title
+    should_validate_uniqueness_of :title, :allow_blank => true
+  end
+
+For those who likes more the RSpec way can simply do:
+
+  describe Post do
+    it { should belong_to(:user) }
+    it { should have_many(:comments) }
+    it { should have_and_belong_to_many(:tags) }
+
+    it { should validate_presence_of(:body) }
+    it { should validate_presence_of(:title) }
+    it { should validate_uniqueness_of(:title, :allow_blank => true) }
+  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 in spec/support/remarkable.rb:
+
+  Remarkable.add_locale 'path/to/my_locale.yml'
+
+And then:
+
+  Remarkable.locale = :my_locale
+
+== Using it outside Rails
+
+If you want to use Remarkable ActiveRecord 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 sources -a http://gems.github.com
+        sudo gem install svenfuchs-i18n
+
+  2. Include the matchers. Remarkable Rails gem is the responsable to add
+     ActiveRecord matchers to rspec. If you are not using it, you have to do:
+
+        Remarkable.include_matchers!(Remarkable::ActiveRecord, RSpec::Core::ExampleGroup)
+
+     This will make ActiveRecord matchers available in all rspec example groups.
+

data/lib/remarkable/active_record.rb

@@ -0,0 +1,14 @@
+# Load Remarkable
+require 'remarkable/active_model'
+require 'remarkable/active_record/base'
+
+# Add default locale
+dir = File.dirname(__FILE__)
+Dir["#{dir}/../../locale/*yml"].each {|f| Remarkable.add_locale(f) }
+
+# Add matchers
+Dir[File.join(dir, 'active_record', 'matchers', '*.rb')].each do |file|
+  require file
+end
+
+Remarkable.include_matchers!(Remarkable::ActiveRecord, RSpec::Core::ExampleGroup)

data/lib/remarkable/active_record/base.rb

@@ -0,0 +1,6 @@
+module Remarkable
+  module ActiveRecord
+    class Base < Remarkable::ActiveModel::Base
+    end
+  end
+end

data/lib/remarkable/active_record/matchers/accept_nested_attributes_for_matcher.rb

@@ -0,0 +1,138 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class AcceptNestedAttributesForMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :collection => :associations, :as => :association
+
+        collection_assertions :association_exists?, :is_autosave?, :responds_to_attributes?,
+                              :allows_destroy?, :accepts?, :rejects?
+
+        optionals :allow_destroy, :default => true
+        optionals :accept, :reject, :splat => true
+
+        protected
+
+          def association_exists?
+            reflection
+          end
+
+          def is_autosave?
+            reflection.options[:autosave] == true
+          end
+
+          def responds_to_attributes?
+            @subject.respond_to?(:"#{@association}_attributes=", true)
+          end
+
+          def allows_destroy?
+            return true unless @options.key?(:allow_destroy)
+
+            @subject.instance_eval <<-ALLOW_DESTROY
+              def assign_nested_attributes_for_#{reflection_type}_association(association, *args)
+                if self.respond_to?(:nested_attributes_options)
+                  self.nested_attributes_options[association.to_sym][:allow_destroy]
+                else
+                  args.last
+                end
+              end
+            ALLOW_DESTROY
+
+            actual = @subject.send(:"#{@association}_attributes=", {})
+            return actual == @options[:allow_destroy], :actual => actual
+          end
+
+          def accepts?
+            return true unless @options.key?(:accept)
+
+            [@options[:accept]].flatten.each do |attributes|
+              return false, :attributes => attributes.inspect if reject_if_proc.call(attributes)
+            end
+
+            true
+          end
+
+          def rejects?
+            return true unless @options.key?(:reject)
+
+            [@options[:reject]].flatten.each do |attributes|
+              return false, :attributes => attributes.inspect unless reject_if_proc.call(attributes)
+            end
+
+            true
+          end
+
+        private
+
+          def reflection
+            @reflection ||= subject_class.reflect_on_association(@association.to_sym)
+          end
+
+          def reflection_type
+            case reflection.macro
+              when :has_one, :belongs_to
+                :one_to_one
+              when :has_many, :has_and_belongs_to_many
+                :collection
+            end
+          end
+
+          def reject_if_proc
+            if subject_class.respond_to?(:nested_attributes_options)
+              subject_class.nested_attributes_options[@association.to_sym][:reject_if]
+            else
+              subject_class.reject_new_nested_attributes_procs[@association.to_sym]
+            end
+          end
+
+      end
+
+      # Ensures that the model accepts nested attributes for the given associations.
+      #
+      # == Options
+      #
+      # * <tt>allow_destroy</tt> - When true allows the association to be destroyed
+      # * <tt>accept</tt> - attributes that should be accepted by the :reject_if proc
+      # * <tt>reject</tt> - attributes that should be rejected by the :reject_if proc
+      #
+      # == Examples
+      #
+      #   should_accept_nested_attributes_for :tasks
+      #   should_accept_nested_attributes_for :tasks, :allow_destroy => true
+      #
+      # :accept and :reject takes objects that are verified against the proc. So
+      # having a model:
+      #
+      #   class Projects < ActiveRecord::Base
+      #     has_many :tasks
+      #     accepts_nested_attributes_for :tasks, :reject_if => proc { |a| a[:title].blank? }
+      #   end
+      #
+      # You can have the following specs:
+      #
+      #   should_accept_nested_attributes_for :tasks, :reject => { :title => '' }        # Passes
+      #   should_accept_nested_attributes_for :tasks, :accept => { :title => 'My task' } # Passes
+      #
+      #   should_accept_nested_attributes_for :tasks, :accept => { :title => 'My task' },
+      #                                               :reject => { :title => '' }        # Passes
+      #
+      #   should_accept_nested_attributes_for :tasks, :accept => { :title => '' }        # Fail
+      #   should_accept_nested_attributes_for :tasks, :reject => { :title => 'My task' } # Fail
+      #
+      # You can also give arrays to :accept and :reject to verify multiple attributes.
+      # In such cases the block syntax is more recommended for readability:
+      #
+      #   should_accept_nested_attributes_for :tasks do
+      #     m.allow_destroy(false)
+      #     m.accept :title => 'My task'
+      #     m.accept :title => 'Another task'
+      #     m.reject :title => nil
+      #     m.reject :title => ''
+      #   end
+      #
+      def accept_nested_attributes_for(*args, &block)
+        AcceptNestedAttributesForMatcher.new(*args, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable/active_record/matchers/allow_mass_assignment_of_matcher.rb

@@ -0,0 +1,74 @@
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class AllowMassAssignmentOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        include Remarkable::Negative
+        arguments :collection => :attributes, :as => :attribute
+
+        assertion :allows?
+        collection_assertions :is_accessible?, :is_protected?
+
+        protected
+
+          # If no attribute is given, check if no attribute is being protected,
+          # otherwise it fails.
+          #
+          def allows?
+            return positive? unless @attributes.empty?
+            protected_attributes.nil? || protected_attributes.empty?
+          end
+
+          def is_accessible?
+            return positive? if accessible_attributes.nil?
+            accessible_attributes.include?(@attribute.to_s)
+          end
+
+          def is_protected?
+            return accessible_attributes.nil? || positive? if protected_attributes.nil?
+            !protected_attributes.include?(@attribute.to_s)
+          end
+
+          def interpolation_options
+            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
+          end
+
+        private
+
+          def accessible_attributes
+            @accessible_attributes ||= unless subject_class.accessible_attributes.empty?
+              subject_class.accessible_attributes
+            else
+              subject_class.column_names - subject_class.protected_attributes.to_a
+            end
+          end
+
+          def protected_attributes
+            @protected_attributes ||= if subject_class.accessible_attributes.empty?
+              subject_class.protected_attributes
+            else
+              subject_class.column_names - subject_class.accessible_attributes.to_a
+            end
+          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, &block)
+        AllowMassAssignmentOfMatcher.new(*attributes, &block).spec(self)
+      end
+    end
+  end
+end