remarkable_activerecord 3.1.8 → 3.1.9

data/lib/remarkable_activerecord/matchers/have_column_matcher.rb

@@ -1,68 +1,68 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class HaveColumnMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :columns, :as => :column
-
-        optional :type, :default, :precision, :limit, :scale, :sql_type
-        optional :primary, :null, :default => true
-
-        collection_assertions :column_exists?, :options_match?
-
-        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)
-            return actual == @options, :actual => actual.inspect
-          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
-            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:
-      #
-      #   :type, :default, :precision, :limit, :scale, :sql_type, :primary, :null
-      #
-      # == Examples
-      #
-      #   should_have_column :name, :type => :string, :default => ''
-      #
-      #   it { should have_column(:name, :type => :string) }
-      #   it { should have_column(:name).type(:string) }
-      # 
-      def have_column(*args, &block)
-        HaveColumnMatcher.new(*args, &block).spec(self)
-      end
-      alias :have_columns    :have_column
-      alias :have_db_column  :have_column
-      alias :have_db_columns :have_column
-
-    end
-  end
-end
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class HaveColumnMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :collection => :columns, :as => :column
+
+        optional :type, :default, :precision, :limit, :scale, :sql_type
+        optional :primary, :null, :default => true
+
+        collection_assertions :column_exists?, :options_match?
+
+        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)
+            return actual == @options, :actual => actual.inspect
+          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
+            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:
+      #
+      #   :type, :default, :precision, :limit, :scale, :sql_type, :primary, :null
+      #
+      # == Examples
+      #
+      #   should_have_column :name, :type => :string, :default => ''
+      #
+      #   it { should have_column(:name, :type => :string) }
+      #   it { should have_column(:name).type(:string) }
+      # 
+      def have_column(*args, &block)
+        HaveColumnMatcher.new(*args, &block).spec(self)
+      end
+      alias :have_columns    :have_column
+      alias :have_db_column  :have_column
+      alias :have_db_columns :have_column
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/have_default_scope_matcher.rb

@@ -1,15 +1,15 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
+module Remarkable
+  module ActiveRecord
+    module Matchers
       class HaveDefaultScopeMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments
+        arguments
         assertions :options_match?
-
+
         optionals :conditions, :include, :joins, :limit, :offset, :order, :select,
                   :readonly, :group, :having, :from, :lock
-
-        protected
-
+
+        protected
+
           def options_match?
             default_scope.include?(@options)
           end
@@ -21,29 +21,29 @@ module Remarkable
             else
               []
             end
-          end
-
-          def interpolation_options
-            { :options => @options.inspect, :actual => default_scope.inspect }
-          end
-
-      end
-
-      # Ensures that the model has a default scope with the given options.
-      #
-      # == Options
-      #
+          end
+
+          def interpolation_options
+            { :options => @options.inspect, :actual => default_scope.inspect }
+          end
+
+      end
+
+      # Ensures that the model has a default scope with the given options.
+      #
+      # == Options
+      #
       # All options that the default scope would pass on to find: :conditions,
       # :include, :joins, :limit, :offset, :order, :select, :readonly, :group,
-      # :having, :from, :lock.
-      #
-      # == Examples
-      #
-      #   it { should have_default_scope(:conditions => {:visible => true}) }
-      #   it { should have_default_scope.conditions(:visible => true) }
-      #
-      # Passes for:
-      #
+      # :having, :from, :lock.
+      #
+      # == Examples
+      #
+      #   it { should have_default_scope(:conditions => {:visible => true}) }
+      #   it { should have_default_scope.conditions(:visible => true) }
+      #
+      # Passes for:
+      #
       #   default_scope :conditions => { :visible => true }
       #
       # If you set two different default scopes, you have to spec them
@@ -58,12 +58,12 @@ module Remarkable
       #   should_have_default_scope :conditions => { :published => true } # Passes
       #
       #   should_have_default_scope :conditions => { :published => true,
-      #                                               :visible => true }  # Fails
-      #
-      def have_default_scope(*args, &block)
-        HaveDefaultScopeMatcher.new(*args, &block).spec(self)
-      end
-
-    end
-  end
-end
+      #                                               :visible => true }  # Fails
+      #
+      def have_default_scope(*args, &block)
+        HaveDefaultScopeMatcher.new(*args, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/have_index_matcher.rb

@@ -1,73 +1,73 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class HaveIndexMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :columns, :as => :column
-
-        optional :table_name
-        optional :unique, :default => true
-
-        collection_assertions :index_exists?, :is_unique?
-
-        protected
-
-          def index_exists?
-            !matched_index.nil?
-          end
-
-          def is_unique?
-            return true unless @options.key?(:unique)
-            return @options[:unique] == matched_index.unique, :actual => matched_index.unique
-          end
-
-          def matched_index
-            columns = [@column].flatten.map(&:to_s)
-            indexes.detect { |ind| ind.columns == columns }
-          end
-
-          def indexes
-            @indexes ||= ::ActiveRecord::Base.connection.indexes(current_table_name)
-          end
-
-          def interpolation_options
-            @subject ? { :table_name => current_table_name } : {}
-          end
-
-        private
-
-          def current_table_name
-            @options[:table_name] || subject_class.table_name
-          end
-
-      end
-
-      # Ensures the database column has specified index.
-      #
-      # == Options
-      #
-      # * <tt>unique</tt> - when supplied, tests if the index is unique or not
-      # * <tt>table_name</tt> - when supplied, tests if the index is defined for the given table
-      #
-      # == Examples
-      #
-      #   it { should have_index(:ssn).unique(true) }
-      #   it { should have_index([:name, :email]).unique(true) }
-      #
-      #   should_have_index :ssn, :unique => true, :limit => 9, :null => false
-      #
-      #   should_have_index :ssn do |m|
-      #     m.unique
-      #     m.limit = 9
-      #     m.null = false
-      #   end
-      #
-      def have_index(*args, &block)
-        HaveIndexMatcher.new(*args, &block).spec(self)
-      end
-      alias :have_indices    :have_index
-      alias :have_db_index   :have_index
-      alias :have_db_indices :have_index
-
-    end
-  end
-end
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class HaveIndexMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :collection => :columns, :as => :column
+
+        optional :table_name
+        optional :unique, :default => true
+
+        collection_assertions :index_exists?, :is_unique?
+
+        protected
+
+          def index_exists?
+            !matched_index.nil?
+          end
+
+          def is_unique?
+            return true unless @options.key?(:unique)
+            return @options[:unique] == matched_index.unique, :actual => matched_index.unique
+          end
+
+          def matched_index
+            columns = [@column].flatten.map(&:to_s)
+            indexes.detect { |ind| ind.columns == columns }
+          end
+
+          def indexes
+            @indexes ||= ::ActiveRecord::Base.connection.indexes(current_table_name)
+          end
+
+          def interpolation_options
+            @subject ? { :table_name => current_table_name } : {}
+          end
+
+        private
+
+          def current_table_name
+            @options[:table_name] || subject_class.table_name
+          end
+
+      end
+
+      # Ensures the database column has specified index.
+      #
+      # == Options
+      #
+      # * <tt>unique</tt> - when supplied, tests if the index is unique or not
+      # * <tt>table_name</tt> - when supplied, tests if the index is defined for the given table
+      #
+      # == Examples
+      #
+      #   it { should have_index(:ssn).unique(true) }
+      #   it { should have_index([:name, :email]).unique(true) }
+      #
+      #   should_have_index :ssn, :unique => true, :limit => 9, :null => false
+      #
+      #   should_have_index :ssn do |m|
+      #     m.unique
+      #     m.limit = 9
+      #     m.null = false
+      #   end
+      #
+      def have_index(*args, &block)
+        HaveIndexMatcher.new(*args, &block).spec(self)
+      end
+      alias :have_indices    :have_index
+      alias :have_db_index   :have_index
+      alias :have_db_indices :have_index
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/have_readonly_attributes_matcher.rb

@@ -1,30 +1,30 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class HaveReadonlyAttributesMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :collection => :attributes, :as => :attribute
-        collection_assertions :is_readonly?
-
-        private
-
-          def is_readonly?
-            readonly = subject_class.readonly_attributes || []
-            return readonly.include?(@attribute.to_s), :actual => readonly.to_a.inspect
-          end
-      end
-
-      # 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, &block)
-        HaveReadonlyAttributesMatcher.new(*attributes, &block).spec(self)
-      end
-      alias :have_readonly_attribute :have_readonly_attributes
-
-    end
-  end
-end
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class HaveReadonlyAttributesMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :collection => :attributes, :as => :attribute
+        collection_assertions :is_readonly?
+
+        private
+
+          def is_readonly?
+            readonly = subject_class.readonly_attributes || []
+            return readonly.include?(@attribute.to_s), :actual => readonly.to_a.inspect
+          end
+      end
+
+      # 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, &block)
+        HaveReadonlyAttributesMatcher.new(*attributes, &block).spec(self)
+      end
+      alias :have_readonly_attribute :have_readonly_attributes
+
+    end
+  end
+end

data/lib/remarkable_activerecord/matchers/have_scope_matcher.rb

@@ -1,85 +1,85 @@
-module Remarkable
-  module ActiveRecord
-    module Matchers
-      class HaveScopeMatcher < Remarkable::ActiveRecord::Base #:nodoc:
-        arguments :scope_name
-        assertions :is_scope?, :options_match?
-
-        optionals :with, :splat => true
-        optionals :conditions, :include, :joins, :limit, :offset, :order, :select,
-                  :readonly, :group, :having, :from, :lock
-
-        protected
-
-          def is_scope?
-            @scope_object = if @options.key?(:with)
-              @options[:with] = [ @options[:with] ] unless Array === @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
-
-      end
-
-      # 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
-      #
-      # All options that the named scope would pass on to find: :conditions,
-      # :include, :joins, :limit, :offset, :order, :select, :readonly, :group,
-      # :having, :from, :lock.
-      #
-      # == Examples
-      # 
-      #   it { should have_scope(:visible, :conditions => {:visible => true}) }
-      #   it { should have_scope(:visible).conditions(:visible => true) }
-      #
-      # Passes for
-      #
-      #   named_scope :visible, :conditions => {:visible => true}
-      #
-      # Or for
-      #
-      #   def self.visible
-      #     scoped(:conditions => {:visible => true})
-      #   end
-      #
-      # You can test lambdas or methods that return ActiveRecord#scoped calls:
-      #
-      #   it { should have_scope(:recent, :with => 5) }
-      #   it { should have_scope(:recent, :with => 1) }
-      #
-      # Passes for
-      #
-      #   named_scope :recent, lambda {|c| {:limit => c}}
-      #
-      # Or for
-      #
-      #   def self.recent(c)
-      #     scoped(:limit => c)
-      #   end
-      #
-      def have_scope(*args, &block)
-        HaveScopeMatcher.new(*args, &block).spec(self)
-      end
-      alias :have_named_scope :have_scope
-
-    end
-  end
-end
+module Remarkable
+  module ActiveRecord
+    module Matchers
+      class HaveScopeMatcher < Remarkable::ActiveRecord::Base #:nodoc:
+        arguments :scope_name
+        assertions :is_scope?, :options_match?
+
+        optionals :with, :splat => true
+        optionals :conditions, :include, :joins, :limit, :offset, :order, :select,
+                  :readonly, :group, :having, :from, :lock
+
+        protected
+
+          def is_scope?
+            @scope_object = if @options.key?(:with)
+              @options[:with] = [ @options[:with] ] unless Array === @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
+
+      end
+
+      # 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
+      #
+      # All options that the named scope would pass on to find: :conditions,
+      # :include, :joins, :limit, :offset, :order, :select, :readonly, :group,
+      # :having, :from, :lock.
+      #
+      # == Examples
+      # 
+      #   it { should have_scope(:visible, :conditions => {:visible => true}) }
+      #   it { should have_scope(:visible).conditions(:visible => true) }
+      #
+      # Passes for
+      #
+      #   named_scope :visible, :conditions => {:visible => true}
+      #
+      # Or for
+      #
+      #   def self.visible
+      #     scoped(:conditions => {:visible => true})
+      #   end
+      #
+      # You can test lambdas or methods that return ActiveRecord#scoped calls:
+      #
+      #   it { should have_scope(:recent, :with => 5) }
+      #   it { should have_scope(:recent, :with => 1) }
+      #
+      # Passes for
+      #
+      #   named_scope :recent, lambda {|c| {:limit => c}}
+      #
+      # Or for
+      #
+      #   def self.recent(c)
+      #     scoped(:limit => c)
+      #   end
+      #
+      def have_scope(*args, &block)
+        HaveScopeMatcher.new(*args, &block).spec(self)
+      end
+      alias :have_named_scope :have_scope
+
+    end
+  end
+end