remarkable_activerecord 3.0.1 → 3.0.2

data/lib/remarkable_activerecord/matchers/allow_values_for_matcher.rb

@@ -1,92 +1,92 @@
 module Remarkable
   module ActiveRecord
-    module Matchers
+    module Matchers
       class AllowValuesForMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-
-        optional :message
-        optional :in, :splat => true
+        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
+
+        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
-      #
+      # 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>.
+      # * <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
-      #
+      # == 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"
+      #   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)
+      def allow_values_for(attribute, *args)
         options = args.extract_options!
         AllowValuesForMatcher.new(attribute, options.merge!(:in => args)).spec(self)
-      end
+      end
       alias :validate_format_of :allow_values_for
 
     end

data/lib/remarkable_activerecord/matchers/association_matcher.rb

@@ -1,230 +1,230 @@
 module Remarkable
   module ActiveRecord
     module Matchers
-      class AssociationMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :macro, :collection => :associations, :as => :association
-
-        optionals :through, :class_name, :foreign_key, :dependent, :join_table, :as
-        optionals :uniq, :readonly, :validate, :autosave, :polymorphic, :counter_cache, :default => true
-
-        # Stores optionals declared above in a CONSTANT to generate assertions
-        ASSOCIATION_OPTIONS = self.matcher_optionals
-
-        collection_assertions :association_exists?, :macro_matches?, :through_exists?,
-                              :join_table_exists?, :foreign_key_exists?, :polymorphic_exists?,
-                              :counter_cache_exists?
-
-        protected
-
-          def association_exists?
+      class AssociationMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :macro, :collection => :associations, :as => :association
+
+        optionals :through, :class_name, :foreign_key, :dependent, :join_table, :as
+        optionals :uniq, :readonly, :validate, :autosave, :polymorphic, :counter_cache, :default => true
+
+        # Stores optionals declared above in a CONSTANT to generate assertions
+        ASSOCIATION_OPTIONS = self.matcher_optionals
+
+        collection_assertions :association_exists?, :macro_matches?, :through_exists?,
+                              :join_table_exists?, :foreign_key_exists?, :polymorphic_exists?,
+                              :counter_cache_exists?
+
+        protected
+
+          def association_exists?
             reflection
           end
 
           def macro_matches?
             reflection.macro == @macro
-          end
-
-          def through_exists?
-            return true unless @options.key?(:through)
-            subject_class.reflect_on_association(@options[:through])
-          end
-
-          def join_table_exists?
-            return true unless has_join_table?
+          end
+
+          def through_exists?
+            return true unless @options.key?(:through)
+            subject_class.reflect_on_association(@options[:through])
+          end
+
+          def join_table_exists?
+            return true unless has_join_table?
             ::ActiveRecord::Base.connection.tables.include?(reflection_join_table)
           end
-
-          def foreign_key_exists?
-            table_has_column?(foreign_key_table, reflection_foreign_key)
-          end
-
-          def polymorphic_exists?
-            return true unless @options[:polymorphic]
-            table_has_column?(subject_class.table_name, reflection_foreign_key.sub(/_id$/, '_type'))
-          end
-
-          def counter_cache_exists?
-            return true unless @options[:counter_cache]
+
+          def foreign_key_exists?
+            table_has_column?(foreign_key_table, reflection_foreign_key)
+          end
+
+          def polymorphic_exists?
+            return true unless @options[:polymorphic]
+            table_has_column?(subject_class.table_name, reflection_foreign_key.sub(/_id$/, '_type'))
+          end
+
+          def counter_cache_exists?
+            return true unless @options[:counter_cache]
             table_has_column?(reflection.klass.table_name, reflection.counter_cache_column.to_s)
-          end
-
-          ASSOCIATION_OPTIONS.each do |option|
-            collection_assertion :"#{option}_matches?"
-
-            class_eval <<-METHOD, __FILE__, __LINE__
-              def #{option}_matches?
-                return true unless @options.key?(#{option.inspect})
-                actual_value = respond_to?(:reflection_#{option}, true) ? reflection_#{option} : reflection.options[#{option.inspect}].to_s
-
-                return true if @options[#{option.inspect}].to_s == actual_value
-              end
-            METHOD
-          end
-
-        private
-
+          end
+
+          ASSOCIATION_OPTIONS.each do |option|
+            collection_assertion :"#{option}_matches?"
+
+            class_eval <<-METHOD, __FILE__, __LINE__
+              def #{option}_matches?
+                return true unless @options.key?(#{option.inspect})
+                actual_value = respond_to?(:reflection_#{option}, true) ? reflection_#{option} : reflection.options[#{option.inspect}].to_s
+
+                return true if @options[#{option.inspect}].to_s == actual_value
+              end
+            METHOD
+          end
+
+        private
+
           def reflection
             @reflection ||= subject_class.reflect_on_association(@association.to_sym)
-          end
-
-          # Rescue nil to avoid raising errors in invalid through associations
-          def reflection_class_name
-            reflection.class_name.to_s rescue nil
-          end
-
+          end
+
+          # Rescue nil to avoid raising errors in invalid through associations
+          def reflection_class_name
+            reflection.class_name.to_s rescue nil
+          end
+
           def reflection_foreign_key
             reflection.primary_key_name.to_s
-          end
-
-          def reflection_join_table
-            (reflection.options[:join_table] || reflection.options[:through]).to_s
-          end
-
+          end
+
+          def reflection_join_table
+            (reflection.options[:join_table] || reflection.options[:through]).to_s
+          end
+
           def has_join_table?
             reflection.options.key?(:through) || reflection.macro == :has_and_belongs_to_many
-          end
-
-          def table_has_column?(table_name, column)
+          end
+
+          def table_has_column?(table_name, column)
             ::ActiveRecord::Base.connection.columns(table_name, 'Remarkable column retrieval').any?{|c| c.name == column }
-          end
-
-          # In cases a join table exists (has_and_belongs_to_many and through
-          # associations), we check the foreign key in the join table.
-          #
-          # On belongs to, the foreign_key is in the subject class table and in
-          # other cases it's on the reflection class table.
-          #
-          def foreign_key_table
-            if has_join_table?
-              reflection_join_table
-            elsif reflection.macro == :belongs_to
-              subject_class.table_name
-            else
-              reflection.klass.table_name
-            end
-          end
-
-          def interpolation_options
-            options = { :macro => Remarkable.t(@macro, :scope => matcher_i18n_scope, :default => @macro.to_s) }
-
-            if @subject && reflection
-              options.merge!(
-                :actual_macro         => Remarkable.t(reflection.macro, :scope => matcher_i18n_scope, :default => reflection.macro.to_s),
-                :subject_table        => subject_class.table_name.inspect,
-                :reflection_table     => reflection.klass.table_name.inspect,
-                :foreign_key_table    => foreign_key_table.inspect,
-                :polymorphic_column   => reflection_foreign_key.sub(/_id$/, '_type').inspect,
-                :counter_cache_column => reflection.counter_cache_column.to_s.inspect
-              ) rescue nil # rescue to allow specs to run properly
-
-              ASSOCIATION_OPTIONS.each do |option|
-                value_to_compare = respond_to?(:"reflection_#{option}", true) ? send(:"reflection_#{option}") : reflection.options[option].to_s
-                options[:"actual_#{option}"] = value_to_compare.inspect
-              end
-
-            end
-
-            options
+          end
+
+          # In cases a join table exists (has_and_belongs_to_many and through
+          # associations), we check the foreign key in the join table.
+          #
+          # On belongs to, the foreign_key is in the subject class table and in
+          # other cases it's on the reflection class table.
+          #
+          def foreign_key_table
+            if has_join_table?
+              reflection_join_table
+            elsif reflection.macro == :belongs_to
+              subject_class.table_name
+            else
+              reflection.klass.table_name
+            end
+          end
+
+          def interpolation_options
+            options = { :macro => Remarkable.t(@macro, :scope => matcher_i18n_scope, :default => @macro.to_s) }
+
+            if @subject && reflection
+              options.merge!(
+                :actual_macro         => Remarkable.t(reflection.macro, :scope => matcher_i18n_scope, :default => reflection.macro.to_s),
+                :subject_table        => subject_class.table_name.inspect,
+                :reflection_table     => reflection.klass.table_name.inspect,
+                :foreign_key_table    => foreign_key_table.inspect,
+                :polymorphic_column   => reflection_foreign_key.sub(/_id$/, '_type').inspect,
+                :counter_cache_column => reflection.counter_cache_column.to_s.inspect
+              ) rescue nil # rescue to allow specs to run properly
+
+              ASSOCIATION_OPTIONS.each do |option|
+                value_to_compare = respond_to?(:"reflection_#{option}", true) ? send(:"reflection_#{option}") : reflection.options[option].to_s
+                options[:"actual_#{option}"] = value_to_compare.inspect
+              end
+
+            end
+
+            options
           end
       end
-
-      # Ensure that the belongs_to relationship exists. Will also test that the
-      # subject table has the association_id column.
-      #
-      # == Options
-      #
-      # * <tt>:class_name</tt> - the expected associted class name.
-      # * <tt>:foreign_key</tt> - the expected foreign key in the subject table.
-      # * <tt>:dependent</tt> - the expected dependent value for the association.
-      # * <tt>:readonly</tt> - checks wether readonly is true or false.
-      # * <tt>:validate</tt> - checks wether validate is true or false.
-      # * <tt>:autosave</tt> - checks wether autosave is true or false.
-      # * <tt>:counter_cache</tt> - the expected dependent value for the association.
-      #   It also checks if the column actually exists in the table.
-      # * <tt>:polymorphic</tt> - if the association should be polymorphic or not.
-      #   When true it also checks for the association_type column in the subject table.
-      #
-      # == Examples
-      #
-      #   should_belong_to :parent, :polymorphic => true
-      #   it { should belong_to(:parent) }
-      #
+
+      # Ensure that the belongs_to relationship exists. Will also test that the
+      # subject table has the association_id column.
+      #
+      # == Options
+      #
+      # * <tt>:class_name</tt> - the expected associted class name.
+      # * <tt>:foreign_key</tt> - the expected foreign key in the subject table.
+      # * <tt>:dependent</tt> - the expected dependent value for the association.
+      # * <tt>:readonly</tt> - checks wether readonly is true or false.
+      # * <tt>:validate</tt> - checks wether validate is true or false.
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      # * <tt>:counter_cache</tt> - the expected dependent value for the association.
+      #   It also checks if the column actually exists in the table.
+      # * <tt>:polymorphic</tt> - if the association should be polymorphic or not.
+      #   When true it also checks for the association_type column in the subject table.
+      #
+      # == Examples
+      #
+      #   should_belong_to :parent, :polymorphic => true
+      #   it { should belong_to(:parent) }
+      #
       def belong_to(*associations)
         AssociationMatcher.new(:belongs_to, *associations).spec(self)
       end
-
-      # Ensures that the has_and_belongs_to_many relationship exists, if the join
-      # table is in place and if the foreign_key column exists.
-      #
-      # == Options
-      #
-      # * <tt>:class_name</tt>  - the expected associted class name.
-      # * <tt>:join_table</tt>  - the expected join table name.
-      # * <tt>:foreign_key</tt> - the expected foreign key in the association table.
-      # * <tt>:uniq</tt>     - checks wether uniq is true or false.
-      # * <tt>:readonly</tt> - checks wether readonly is true or false.
-      # * <tt>:validate</tt> - checks wether validate is true or false.
-      # * <tt>:autosave</tt> - checks wether autosave is true or false.
-      #
-      # == Examples
-      #
-      #  should_have_and_belong_to_many :posts, :cars
-      #  it{ should have_and_belong_to_many :posts, :cars }
+
+      # Ensures that the has_and_belongs_to_many relationship exists, if the join
+      # table is in place and if the foreign_key column exists.
+      #
+      # == Options
+      #
+      # * <tt>:class_name</tt>  - the expected associted class name.
+      # * <tt>:join_table</tt>  - the expected join table name.
+      # * <tt>:foreign_key</tt> - the expected foreign key in the association table.
+      # * <tt>:uniq</tt>     - checks wether uniq is true or false.
+      # * <tt>:readonly</tt> - checks wether readonly is true or false.
+      # * <tt>:validate</tt> - checks wether validate is true or false.
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # == Examples
+      #
+      #  should_have_and_belong_to_many :posts, :cars
+      #  it{ should have_and_belong_to_many :posts, :cars }
       #
       def have_and_belong_to_many(*associations)
         AssociationMatcher.new(:has_and_belongs_to_many, *associations).spec(self)
-      end
-
-      # Ensures that the has_many relationship exists. Will also test that the
-      # associated table has the required columns. It works by default with 
-      # polymorphic association (:as does not have to be supplied).
-      #
-      # == Options
-      #
-      # * <tt>:class_name</tt>  - the expected associted class name.
-      # * <tt>:through</tt>     - the expected join model which to perform the query.
-      #   It also checks if the through table exists.
-      # * <tt>:foreign_key</tt> - the expected foreign key in the associated table.
-      #   When used with :through, it will check for the foreign key in the join table.
-      # * <tt>:dependent</tt>   - the expected dependent value for the association.
-      # * <tt>:uniq</tt>     - checks wether uniq is true or false.
-      # * <tt>:readonly</tt> - checks wether readonly is true or false.
-      # * <tt>:validate</tt> - checks wether validate is true or false.
-      # * <tt>:autosave</tt> - checks wether autosave is true or false.
-      #
-      # == Examples
-      #
-      #   should_have_many :friends
-      #   should_have_many :enemies, :through => :friends
-      #   should_have_many :enemies, :dependent => :destroy
-      #
-      #   it{ should have_many(:friends) }
-      #   it{ should have_many(:enemies, :through => :friends) }
-      #   it{ should have_many(:enemies, :dependent => :destroy) }
+      end
+
+      # Ensures that the has_many relationship exists. Will also test that the
+      # associated table has the required columns. It works by default with 
+      # polymorphic association (:as does not have to be supplied).
+      #
+      # == Options
+      #
+      # * <tt>:class_name</tt>  - the expected associted class name.
+      # * <tt>:through</tt>     - the expected join model which to perform the query.
+      #   It also checks if the through table exists.
+      # * <tt>:foreign_key</tt> - the expected foreign key in the associated table.
+      #   When used with :through, it will check for the foreign key in the join table.
+      # * <tt>:dependent</tt>   - the expected dependent value for the association.
+      # * <tt>:uniq</tt>     - checks wether uniq is true or false.
+      # * <tt>:readonly</tt> - checks wether readonly is true or false.
+      # * <tt>:validate</tt> - checks wether validate is true or false.
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # == Examples
+      #
+      #   should_have_many :friends
+      #   should_have_many :enemies, :through => :friends
+      #   should_have_many :enemies, :dependent => :destroy
+      #
+      #   it{ should have_many(:friends) }
+      #   it{ should have_many(:enemies, :through => :friends) }
+      #   it{ should have_many(:enemies, :dependent => :destroy) }
       #
       def have_many(*associations)
         AssociationMatcher.new(:has_many, *associations).spec(self)
       end
-
-      # Ensures that the has_many relationship exists. Will also test that the
-      # associated table has the required columns. It works by default with 
-      # polymorphic association (:as does not have to be supplied).
-      #
-      # == Options
-      #
-      # * <tt>:class_name</tt>  - the expected associted class name.
-      # * <tt>:through</tt>     - the expected join model which to perform the query.
-      #   It also checks if the through table exists.
-      # * <tt>:foreign_key</tt> - the expected foreign key in the associated table.
-      #   When used with :through, it will check for the foreign key in the join table.
-      # * <tt>:dependent</tt>   - the expected dependent value for the association.
-      # * <tt>:validate</tt> - checks wether validate is true or false.
-      # * <tt>:autosave</tt> - checks wether autosave is true or false.
-      #
-      # == Examples
-      #
-      #  should_have_one :universe
-      #  it{ should have_one(:universe) }
+
+      # Ensures that the has_many relationship exists. Will also test that the
+      # associated table has the required columns. It works by default with 
+      # polymorphic association (:as does not have to be supplied).
+      #
+      # == Options
+      #
+      # * <tt>:class_name</tt>  - the expected associted class name.
+      # * <tt>:through</tt>     - the expected join model which to perform the query.
+      #   It also checks if the through table exists.
+      # * <tt>:foreign_key</tt> - the expected foreign key in the associated table.
+      #   When used with :through, it will check for the foreign key in the join table.
+      # * <tt>:dependent</tt>   - the expected dependent value for the association.
+      # * <tt>:validate</tt> - checks wether validate is true or false.
+      # * <tt>:autosave</tt> - checks wether autosave is true or false.
+      #
+      # == Examples
+      #
+      #  should_have_one :universe
+      #  it{ should have_one(:universe) }
       #
       def have_one(*associations)
         AssociationMatcher.new(:has_one, *associations).spec(self)