remarkable_activerecord 3.0.1 → 3.0.2

data/lib/remarkable_activerecord/matchers/have_column_matcher.rb

@@ -8,59 +8,59 @@ module Remarkable
         optional :primary, :null, :default => true
 
         collection_assertions :column_exists?, :options_match?
-
-        before_assert do
-          @options.each{|k,v| @options[k] = v.to_s}
-        end
+
+        before_assert do
+          @options.each{|k,v| @options[k] = v.to_s}
+        end
 
         protected
 
           def column_exists?
             !column_type.nil?
           end
-
-          def options_match?
-            actual = get_column_options(column_type, @options.keys)
+
+          def options_match?
+            actual = get_column_options(column_type, @options.keys)
             return actual == @options, :actual => actual.inspect
-          end
-
-          def column_type
-            subject_class.columns.detect {|c| c.name == @column.to_s }
-          end
+          end
+
+          def column_type
+            subject_class.columns.detect {|c| c.name == @column.to_s }
+          end
 
           def get_column_options(column, keys)
-            keys.inject({}) do |hash, key|
-              hash[key] = column.instance_variable_get("@#{key}").to_s
-              hash
+            keys.inject({}) do |hash, key|
+              hash[key] = column.instance_variable_get("@#{key}").to_s
+              hash
             end
-          end
-
-          def interpolation_options
-            { :options => @options.inspect }
-          end
+          end
+
+          def interpolation_options
+            { :options => @options.inspect }
+          end
 
       end
 
       # Ensures that a column of the database actually exists.
       #
       # == Options
-      # 
-      # * All options available in migrations are available:
+      # 
+      # * All options available in migrations are available:
       #
       #   :type, :default, :precision, :limit, :scale, :sql_type, :primary, :null
       #
-      # == Examples
-      #
+      # == Examples
+      #
       #   should_have_column :name, :type => :string, :default => ''
-      #
+      #
       #   it { should have_column(:name, :type => :string) }
-      #   it { should have_column(:name).type(:string) }
+      #   it { should have_column(:name).type(:string) }
       # 
       def have_column(*args)
         HaveColumnMatcher.new(*args).spec(self)
-      end
-      alias :have_columns    :have_column
-      alias :have_db_column  :have_column
+      end
+      alias :have_columns    :have_column
+      alias :have_db_column  :have_column
       alias :have_db_columns :have_column
 
     end

data/lib/remarkable_activerecord/matchers/have_index_matcher.rb

@@ -2,14 +2,14 @@ module Remarkable
   module ActiveRecord
     module Matchers
       class HaveIndexMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :columns, :as => :column
-
-        optional :unique, :default => true
-
-        collection_assertions :index_exists?, :is_unique?
-
-        protected
-
+        arguments :collection => :columns, :as => :column
+
+        optional :unique, :default => true
+
+        collection_assertions :index_exists?, :is_unique?
+
+        protected
+
           def index_exists?
             !matched_index.nil?
           end
@@ -26,31 +26,31 @@ module Remarkable
 
           def indexes
             @indexes ||= ::ActiveRecord::Base.connection.indexes(subject_class.table_name)
-          end
-
-          def interpolation_options
-            @subject ? { :table_name => subject_class.table_name } : {}
           end
 
-      end
-
+          def interpolation_options
+            @subject ? { :table_name => subject_class.table_name } : {}
+          end
+
+      end
+
       # Ensures the database column has specified index.
       #
-      # == Options
+      # == Options
       #
       # * <tt>unique</tt> - when supplied, tests if the index is unique or not
       #
-      # == Examples
+      # == Examples
       #
-      #   it { should have_index(:ssn).unique(true) }
+      #   it { should have_index(:ssn).unique(true) }
       #   it { should have_index([:name, :email]).unique(true) }
       #
       def have_index(*args)
         HaveIndexMatcher.new(*args).spec(self)
       end
-      alias :have_indices    :have_index
-      alias :have_db_index   :have_index
-      alias :have_db_indices :have_index
+      alias :have_indices    :have_index
+      alias :have_db_index   :have_index
+      alias :have_db_indices :have_index
 
     end
   end

data/lib/remarkable_activerecord/matchers/have_readonly_attributes_matcher.rb

@@ -1,9 +1,9 @@
 module Remarkable
   module ActiveRecord
     module Matchers
-      class HaveReadonlyAttributesMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+      class HaveReadonlyAttributesMatcher < Remarkable::ActiveRecord::Base #:nodoc:
         arguments :collection => :attributes, :as => :attribute
-        collection_assertions :is_readonly?
+        collection_assertions :is_readonly?
 
         private
 
@@ -13,17 +13,17 @@ module Remarkable
           end
       end
 
-      # Ensures that the attribute cannot be changed once the record has been
-      # created.
-      #
+      # Ensures that the attribute cannot be changed once the record has been
+      # created.
+      #
       # == Examples
       #
       #   it { should have_readonly_attributes(:password, :admin_flag) }
       #
       def have_readonly_attributes(*attributes)
         HaveReadonlyAttributesMatcher.new(*attributes).spec(self)
-      end
-      alias :have_readonly_attribute :have_readonly_attributes
+      end
+      alias :have_readonly_attribute :have_readonly_attributes
 
     end
   end

data/lib/remarkable_activerecord/matchers/have_scope_matcher.rb

@@ -1,48 +1,48 @@
 module Remarkable
   module ActiveRecord
     module Matchers
-      class HaveScopeMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :scope_name
-        assertions :is_scope?, :options_match?
-
-        optionals :with, :select, :conditions, :order, :limit, :offset
-
-        protected
-
-          def is_scope?
-            @scope_object = if @options[:with]
-              subject_class.send(@scope_name, *@options[:with])
-            else
-              subject_class.send(@scope_name)
-            end
-
-            @scope_object.class == ::ActiveRecord::NamedScope::Scope
-          end
-
+      class HaveScopeMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :scope_name
+        assertions :is_scope?, :options_match?
+
+        optionals :with, :select, :conditions, :order, :limit, :offset
+
+        protected
+
+          def is_scope?
+            @scope_object = if @options[:with]
+              subject_class.send(@scope_name, *@options[:with])
+            else
+              subject_class.send(@scope_name)
+            end
+
+            @scope_object.class == ::ActiveRecord::NamedScope::Scope
+          end
+
           def options_match?
             @options.empty? || @scope_object.proxy_options == @options.except(:with)
           end
 
-          def interpolation_options
-            { :options => @options.except(:with).inspect,
-              :actual  => (@scope_object ? @scope_object.proxy_options.inspect : '{}')
-            }
-          end
+          def interpolation_options
+            { :options => @options.except(:with).inspect,
+              :actual  => (@scope_object ? @scope_object.proxy_options.inspect : '{}')
+            }
+          end
 
       end
 
-      # Ensures that the model has a method named scope that returns a NamedScope
+      # Ensures that the model has a method named scope that returns a NamedScope
       # object with the supplied proxy options.
       #
-      # == Options
-      #
-      # * <tt>with</tt> - Options to be sent to the named scope
-      #
-      # And all other options that the named scope would pass on to find.
-      #
+      # == Options
+      #
+      # * <tt>with</tt> - Options to be sent to the named scope
+      #
+      # And all other options that the named scope would pass on to find.
+      #
       # == Examples
       # 
-      #   it { should have_scope(:visible, :conditions => {:visible => true}) }
+      #   it { should have_scope(:visible, :conditions => {:visible => true}) }
       #   it { should have_scope(:visible).conditions(:visible => true) }
       #
       # Passes for
@@ -60,7 +60,7 @@ module Remarkable
       #   it { should have_scope(:recent, :with => 5) }
       #   it { should have_scope(:recent, :with => 1) }
       #
-      # Passes for
+      # Passes for
       #
       #   named_scope :recent, lambda {|c| {:limit => c}}
       #
@@ -72,8 +72,8 @@ module Remarkable
       #
       def have_scope(*args)
         HaveScopeMatcher.new(*args).spec(self)
-      end
-      alias :have_named_scope :have_scope
+      end
+      alias :have_named_scope :have_scope
 
     end
   end

data/lib/remarkable_activerecord/matchers/validate_acceptance_of_matcher.rb

@@ -1,50 +1,50 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class ValidateAcceptanceOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-
-        optional :accept, :message
-        optional :allow_nil, :default => true
-
-        collection_assertions :requires_acceptance?, :accept_is_valid?, :allow_nil?
-
-        default_options :message => :accepted
-
-        protected
-
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class ValidateAcceptanceOfMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :accept, :message
+        optional :allow_nil, :default => true
+
+        collection_assertions :requires_acceptance?, :accept_is_valid?, :allow_nil?
+
+        default_options :message => :accepted
+
+        protected
+
           def requires_acceptance?
             bad?(false)
-          end
-
-          def accept_is_valid?
-            return true unless @options.key?(:accept)
-            good?(@options[:accept])
-          end
-
-      end
-
+          end
+
+          def accept_is_valid?
+            return true unless @options.key?(:accept)
+            good?(@options[:accept])
+          end
+
+      end
+
       # Ensures that the model cannot be saved if one of the attributes listed is not accepted.
       #
-      # == Options
-      #
-      # * <tt>:accept</tt> - the expected value to be accepted.
+      # == Options
+      #
+      # * <tt>:accept</tt> - the expected value to be accepted.
       # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil 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.accepted')</tt>
       #
-      # == Examples
-      #
-      #   should_validate_acceptance_of :eula, :terms
-      #   should_validate_acceptance_of :eula, :terms, :accept => true
+      # == Examples
+      #
+      #   should_validate_acceptance_of :eula, :terms
+      #   should_validate_acceptance_of :eula, :terms, :accept => true
       #
-      #   it { should validate_acceptance_of(:eula, :terms) }
+      #   it { should validate_acceptance_of(:eula, :terms) }
       #   it { should validate_acceptance_of(:eula, :terms, :accept => true) }
       #
       def validate_acceptance_of(*attributes)
         ValidateAcceptanceOfMatcher.new(*attributes).spec(self)
-      end
-
-    end
-  end
-end
+      end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/validate_associated_matcher.rb

@@ -6,91 +6,91 @@ module Remarkable
         optional  :message, :builder
 
         collection_assertions :find_association?, :is_valid?
-        default_options :message => :invalid
-
-        protected
-
-          def find_association?
-            reflection = @subject.class.reflect_on_association(@association)
-
-            raise ScriptError, "Could not find association #{@association} on #{subject_class}." unless reflection
-
-            associated_object = if builder = @options[:builder] || @block
-              builder.call(@subject)
-            elsif [:belongs_to, :has_one].include?(reflection.macro)
-              @subject.send(:"build_#{@association}") rescue nil
-            else
-              @subject.send(@association).build rescue nil
-            end
-
-            raise ScriptError, "The association object #{@association} could not be built. You can give me " <<
-                               ":builder as option or a block which returns an association." unless associated_object
-
-            raise ScriptError, "The associated object #{@association} is not invalid. You can give me " <<
-                               ":builder as option or a block which returns an invalid association." if associated_object.save
-
-            return true
-          end
-
-          def is_valid?
-            return false if @subject.valid?
-
-            error_message_to_expect = error_message_from_model(@subject, :base, @options[:message])
-
-            # In Rails 2.1.2, the error on association returns a symbol (:invalid)
-            # instead of the message, so we check this case here.
+        default_options :message => :invalid
+
+        protected
+
+          def find_association?
+            reflection = @subject.class.reflect_on_association(@association)
+
+            raise ScriptError, "Could not find association #{@association} on #{subject_class}." unless reflection
+
+            associated_object = if builder = @options[:builder] || @block
+              builder.call(@subject)
+            elsif [:belongs_to, :has_one].include?(reflection.macro)
+              @subject.send(:"build_#{@association}") rescue nil
+            else
+              @subject.send(@association).build rescue nil
+            end
+
+            raise ScriptError, "The association object #{@association} could not be built. You can give me " <<
+                               ":builder as option or a block which returns an association." unless associated_object
+
+            raise ScriptError, "The associated object #{@association} is not invalid. You can give me " <<
+                               ":builder as option or a block which returns an invalid association." if associated_object.save
+
+            return true
+          end
+
+          def is_valid?
+            return false if @subject.valid?
+
+            error_message_to_expect = error_message_from_model(@subject, :base, @options[:message])
+
+            # In Rails 2.1.2, the error on association returns a symbol (:invalid)
+            # instead of the message, so we check this case here.
             @subject.errors.on(@association) == @options[:message] ||
-            assert_contains(@subject.errors.on(@association), error_message_to_expect)
+            assert_contains(@subject.errors.on(@association), error_message_to_expect)
           end
       end
 
-      # Ensures that the model is invalid if one of the associations given is
-      # invalid. It tries to build the association automatically. In has_one
-      # and belongs_to cases, it will build it like this:
-      #
-      #   @model.build_association
-      #   @project.build_manager
-      #
-      # In has_many and has_and_belongs_to_many to cases it will build it like
-      # this:
-      #
-      #   @model.association.build
-      #   @project.tasks.build
-      #
-      # The object returned MUST be invalid and it's likely the case, since the
-      # associated object is empty when calling build. However, if the associated
-      # object has to be manipulated to be invalid, you will have to give :builder
-      # as option or a block to manipulate it:
-      #
-      #   should_validate_associated(:tasks) do |project|
-      #     project.tasks.build(:captcha => 'i_am_a_bot')
-      #   end
-      #
-      # In the case above, the associated object task is only invalid when the
-      # captcha attribute is set. So we give a block to the matcher that tell
-      # exactly how to build an invalid object.
-      #
-      # The example above can also be written as:
-      #
-      #   should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      # Ensures that the model is invalid if one of the associations given is
+      # invalid. It tries to build the association automatically. In has_one
+      # and belongs_to cases, it will build it like this:
+      #
+      #   @model.build_association
+      #   @project.build_manager
+      #
+      # In has_many and has_and_belongs_to_many to cases it will build it like
+      # this:
+      #
+      #   @model.association.build
+      #   @project.tasks.build
+      #
+      # The object returned MUST be invalid and it's likely the case, since the
+      # associated object is empty when calling build. However, if the associated
+      # object has to be manipulated to be invalid, you will have to give :builder
+      # as option or a block to manipulate it:
+      #
+      #   should_validate_associated(:tasks) do |project|
+      #     project.tasks.build(:captcha => 'i_am_a_bot')
+      #   end
+      #
+      # In the case above, the associated object task is only invalid when the
+      # captcha attribute is set. So we give a block to the matcher that tell
+      # exactly how to build an invalid object.
+      #
+      # The example above can also be written as:
+      #
+      #   should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      #
+      # == Options
+      #
+      # * <tt>:builder</tt> - a proc to build the association
       #
-      # == Options
-      #
-      # * <tt>:builder</tt> - a proc to build the association
-      #
       # * <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_validate_associated :tasks
-      #   should_validate_associated(:tasks){ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
-      #   should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      # == Examples
       #
-      #   it { should validate_associated(:tasks) }
-      #   it { should validate_associated(:tasks){ |p| p.tasks.build(:captcha => 'i_am_a_bot') } }
+      #   should_validate_associated :tasks
+      #   should_validate_associated(:tasks){ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      #   should_validate_associated :tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }
+      #
+      #   it { should validate_associated(:tasks) }
+      #   it { should validate_associated(:tasks){ |p| p.tasks.build(:captcha => 'i_am_a_bot') } }
       #   it { should validate_associated(:tasks, :builder => proc{ |p| p.tasks.build(:captcha => 'i_am_a_bot') }) }
-      #
+      #
       def validate_associated(*args, &block)
         ValidateAssociatedMatcher.new(*args, &block).spec(self)
       end