carlosbrando-remarkable 0.0.99 → 2.2.1

data/lib/remarkable/active_record/macros/associations/have_many.rb

@@ -1,160 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class HaveMany
-        include Remarkable::Private
-        
-        def initialize(*associations)
-          @through, @dependent = get_options!(associations, :through, :dependent)
-          @associations = associations
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            @associations.each do |association|
-              reflection = klass.reflect_on_association(association)
-              fail("#{klass.name} does not have any relationship to #{association}") unless reflection && reflection.macro == :has_many
-
-              if @through
-                through_reflection = klass.reflect_on_association(@through)
-                fail("#{klass.name} does not have any relationship to #{@through}") unless through_reflection && @through == reflection.options[:through]
-              end
-
-              if @dependent
-                fail("#{association} should have #{@dependent} dependency") unless @dependent.to_s == reflection.options[:dependent].to_s
-              end
-
-              # Check for the existence of the foreign key on the other table
-              unless reflection.options[:through]
-                if reflection.options[:foreign_key]
-                  fk = reflection.options[:foreign_key]
-                elsif reflection.options[:as]
-                  fk = reflection.options[:as].to_s.foreign_key
-                else
-                  fk = reflection.primary_key_name
-                end
-
-                associated_klass_name = (reflection.options[:class_name] || association.to_s.classify)
-                associated_klass = associated_klass_name.constantize
-
-                fail("#{associated_klass.name} does not have a #{fk} foreign key.") unless associated_klass.column_names.include?(fk.to_s)
-              end
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          message = "have many #{@associations.to_sentence}"
-          message += " through #{@through}" if @through
-          message += " dependent => #{@dependent}" if @dependent
-          message
-        end
-
-        def failure_message
-          message = "expected #{@klass.name} to have many #{@associations.to_sentence}"
-          message += " through #{@through}" if @through
-          message += " dependent => #{@dependent}" if @dependent
-          message += ", but it didn't"
-          @failure_message || message
-        end
-
-        def negative_failure_message
-          message = "expected #{@klass.name} not to have many #{@associations.to_sentence}"
-          message += " through #{@through}" if @through
-          message += " dependent => #{@dependent}" if @dependent
-          message += ", but it did"
-          message
-        end
-      end
-
-      # Ensures that the has_many relationship exists.  Will also test that the
-      # associated table has the required columns.  Works with polymorphic
-      # associations.
-      #
-      # Options:
-      # * <tt>:through</tt> - association name for <tt>has_many :through</tt>
-      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
-      #
-      # Example:
-      #   it { User.should have_many(:friends) }
-      #   it { User.should have_many(:enemies, :through => :friends) }
-      #   it { User.should have_many(:friends, :dependent => :destroy) }
-      #
-      def have_many(*associations)
-        Remarkable::Syntax::RSpec::HaveMany.new(*associations)
-      end
-    end
-
-    module Shoulda
-      # Ensures that the has_many relationship exists.  Will also test that the
-      # associated table has the required columns.  Works with polymorphic
-      # associations.
-      #
-      # Options:
-      # * <tt>:through</tt> - association name for <tt>has_many :through</tt>
-      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
-      #
-      # Example:
-      #   should_have_many :friends
-      #   should_have_many :enemies, :through => :friends
-      #   should_have_many :enemies, :dependent => :destroy
-      #
-      def should_have_many(*associations)
-        through, dependent = get_options!(associations, :through, :dependent)
-        klass = model_class
-        associations.each do |association|
-          name = "should have many #{association}"
-          name += " through #{through}" if through
-          name += " dependent => #{dependent}" if dependent
-          it name do
-            reflection = klass.reflect_on_association(association)
-            unless reflection
-              fail_with("#{klass.name} does not have any relationship to #{association}")
-            end
-            reflection.macro.should == :has_many
-
-            if through
-              through_reflection = klass.reflect_on_association(through)
-              unless through_reflection
-                fail_with("#{klass.name} does not have any relationship to #{through}")
-              end
-              reflection.options[:through].should == through
-            end
-
-            if dependent
-              unless reflection.options[:dependent].to_s == dependent.to_s
-                fail_with("#{association} should have #{dependent} dependency")
-              end
-            end
-
-            # Check for the existence of the foreign key on the other table
-            unless reflection.options[:through]
-              if reflection.options[:foreign_key]
-                fk = reflection.options[:foreign_key]
-              elsif reflection.options[:as]
-                fk = reflection.options[:as].to_s.foreign_key
-              else
-                fk = reflection.primary_key_name
-              end
-
-              associated_klass_name = (reflection.options[:class_name] || association.to_s.classify)
-              associated_klass = associated_klass_name.constantize
-
-              unless associated_klass.column_names.include?(fk.to_s)
-                fail_with("#{associated_klass.name} does not have a #{fk} foreign key.") 
-              end
-            end
-          end
-        end
-      end
-    end
-
-  end
-end

data/lib/remarkable/active_record/macros/associations/have_one.rb

@@ -1,133 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class HaveOne
-        include Remarkable::Private
-        
-        def initialize(*associations)
-          @dependent = get_options!(associations, :dependent)
-          @associations = associations
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            @associations.each do |association|
-              reflection = klass.reflect_on_association(association)
-              fail("#{klass.name} does not have any relationship to #{association}") unless reflection && reflection.macro == :has_one
-
-              associated_klass = (reflection.options[:class_name] || association.to_s.camelize).constantize
-
-              if reflection.options[:foreign_key]
-                fk = reflection.options[:foreign_key]
-              elsif reflection.options[:as]
-                fk = reflection.options[:as].to_s.foreign_key
-                fk_type = fk.gsub(/_id$/, '_type')
-
-                fail("#{associated_klass.name} does not have a #{fk_type} column.") unless associated_klass.column_names.include?(fk_type)
-              else
-                fk = klass.name.foreign_key
-              end
-
-              fail("#{associated_klass.name} does not have a #{fk} foreign key.") unless associated_klass.column_names.include?(fk.to_s)
-
-              if @dependent
-                fail("#{association} should have #{@dependent} dependency") unless @dependent.to_s == reflection.options[:dependent].to_s
-              end
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          message = "have one #{@associations.to_sentence}"
-          message += " dependent => #{@dependent}" if @dependent
-          message
-        end
-
-        def failure_message
-          message = "expected #{@klass.name} to have one #{@associations.to_sentence}"
-          message += " dependent => #{@dependent}" if @dependent      
-          message += ", but it didn't"      
-          @failure_message || message
-        end
-
-        def negative_failure_message
-          message = "expected #{@klass.name} not to have one #{@associations.to_sentence}"
-          message += " dependent => #{@dependent}" if @dependent
-          message += ", but it did"
-          message
-        end
-      end
-
-      # Ensure that the has_one relationship exists.  Will also test that the
-      # associated table has the required columns.  Works with polymorphic
-      # associations.
-      #
-      # Options:
-      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
-      #
-      # Example:
-      #   it { User.should have_one(:address) }
-      #
-      def have_one(*associations)
-        Remarkable::Syntax::RSpec::HaveOne.new(*associations)
-      end
-    end
-
-    module Shoulda
-      # Ensure that the has_one relationship exists.  Will also test that the
-      # associated table has the required columns.  Works with polymorphic
-      # associations.
-      #
-      # Options:
-      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
-      #
-      # Example:
-      #   should_have_one :god # unless hindu
-      #
-      def should_have_one(*associations)
-        dependent = get_options!(associations, :dependent)
-        klass = model_class
-        associations.each do |association|
-          name = "should have one #{association}"
-          name += " dependent => #{dependent}" if dependent
-          it name do
-            reflection = klass.reflect_on_association(association)
-            fail_with("#{klass.name} does not have any relationship to #{association}") unless reflection
-            reflection.macro.should == :has_one
-
-            associated_klass = (reflection.options[:class_name] || association.to_s.camelize).constantize
-
-            if reflection.options[:foreign_key]
-              fk = reflection.options[:foreign_key]
-            elsif reflection.options[:as]
-              fk = reflection.options[:as].to_s.foreign_key
-              fk_type = fk.gsub(/_id$/, '_type')
-              unless associated_klass.column_names.include?(fk_type)
-                fail_with "#{associated_klass.name} does not have a #{fk_type} column."
-              end
-            else
-              fk = klass.name.foreign_key
-            end
-            unless associated_klass.column_names.include?(fk.to_s)
-              fail_with "#{associated_klass.name} does not have a #{fk} foreign key."
-            end
-
-            if dependent
-              unless reflection.options[:dependent].to_s == dependent.to_s
-                fail_with "#{association} should have #{dependent} dependency"
-              end
-            end
-          end
-        end
-      end
-    end
-
-  end
-end

data/lib/remarkable/active_record/macros/database/have_db_column.rb

@@ -1,81 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class HaveDbColumn
-        def initialize(name, opts)
-          @name = name
-          @opts = opts
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          column = klass.columns.detect {|c| c.name == @name.to_s }
-          fail("#{klass.name} does not have column #{@name}") unless column
-
-          @opts.each do |k, v|
-            fail(":#{@name} column on table for #{klass} does not match option :#{k}") unless column.instance_variable_get("@#{k}").to_s == v.to_s
-          end
-        end
-
-        def description
-          message = "have column named :#{@name}"
-          message += " with options " + @opts.inspect unless @opts.empty?
-          message
-        end
-
-        def failure_message
-          message = "expected #{@klass.name} to have column named :#{@name}"
-          message += " with options " + @opts.inspect unless @opts.empty?
-          message += ", but it didn't"
-
-          @failure_message || message
-        end
-
-        def negative_failure_message
-          message = "expected #{@klass.name} not to have column named :#{@name}"
-          message += " with options " + @opts.inspect unless @opts.empty?
-          message += ", but it did"
-          message
-        end
-      end
-
-      # Ensure that the given column is defined on the models backing SQL table.  The options are the same as
-      # the instance variables defined on the column definition:  :precision, :limit, :default, :null,
-      # :primary, :type, :scale, and :sql_type.
-      #
-      #   it { User.should have_db_column(:email, :type => "string",  :default => nil,    :precision => nil,  :limit => 255,
-      #                                           :null => true,      :primary => false,  :scale => nil,      :sql_type => 'varchar(255)') }
-      # 
-      def have_db_column(name, opts = {})
-        Remarkable::Syntax::RSpec::HaveDbColumn.new(name, opts)
-      end
-    end
-
-    module Shoulda
-      # Ensure that the given column is defined on the models backing SQL table.  The options are the same as
-      # the instance variables defined on the column definition:  :precision, :limit, :default, :null,
-      # :primary, :type, :scale, and :sql_type.
-      #
-      #   should_have_db_column :email, :type => "string", :default => nil,   :precision => nil, :limit    => 255,
-      #                                 :null => true,     :primary => false, :scale     => nil, :sql_type => 'varchar(255)'
-      #
-      def should_have_db_column(name, opts = {})
-        klass = model_class
-        test_name = "should have column named :#{name}"
-        test_name += " with options " + opts.inspect unless opts.empty?
-        it test_name do
-          column = klass.columns.detect {|c| c.name == name.to_s }
-          fail_with("#{klass.name} does not have column #{name}") unless column
-          opts.each do |k, v|
-            unless v.to_s == column.instance_variable_get("@#{k}").to_s
-              fail_with(":#{name} column on table for #{klass} does not match option :#{k}")
-            end
-          end
-        end
-      end
-    end
-
-  end
-end

data/lib/remarkable/active_record/macros/database/have_db_columns.rb

@@ -1,73 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class HaveDbColumns
-        include Remarkable::Private
-        
-        def initialize(*columns)
-          @column_type = get_options!(columns, :type)
-          @columns = columns
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          @columns.each do |name|
-            column = klass.columns.detect {|c| c.name == name.to_s }
-            fail("#{klass.name} does not have column #{name}") unless column
-          end
-        end
-
-        def description
-          message = "have columns #{@columns.to_sentence}"
-          message += " of type #{@column_type}" if @column_type
-          message
-        end
-
-        def failure_message
-          message = "expected to have columns #{@columns.to_sentence}"
-          message += " of type #{@column_type}" if @column_type
-          message += ", but it didn't"
-
-          @failure_message || message
-        end
-
-        def negative_failure_message
-          message = "expected not to have columns #{@columns.to_sentence}"
-          message += " of type #{@column_type}" if @column_type
-          message += ", but it did"
-          message
-        end
-      end
-
-      # Ensure that the given columns are defined on the models backing SQL table.
-      #
-      #   it { User.should have_db_columns(:id, :email, :name, :created_at) }
-      #
-      def have_db_columns(*columns)
-        Remarkable::Syntax::RSpec::HaveDbColumns.new(*columns)
-      end
-    end
-
-    module Shoulda
-      # Ensure that the given columns are defined on the models backing SQL table.
-      #
-      #   should_have_db_columns :id, :email, :name, :created_at
-      #
-      def should_have_db_columns(*columns)
-        column_type = get_options!(columns, :type)
-        klass = model_class
-        columns.each do |name|
-          test_name = "should have column #{name}"
-          test_name += " of type #{column_type}" if column_type
-          it test_name do
-            column = klass.columns.detect {|c| c.name == name.to_s }
-            fail_with("#{klass.name} does not have column #{name}") unless column
-          end
-        end
-      end
-    end
-
-  end
-end

data/lib/remarkable/active_record/macros/database/have_indices.rb

@@ -1,75 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class HaveIndices
-        def initialize(*columns)
-          @columns = columns
-        end
-
-        def matches?(klass)
-          @table = klass.table_name
-          indices = ::ActiveRecord::Base.connection.indexes(@table).map(&:columns)
-
-          @columns.each do |column|
-            columns = [column].flatten.map(&:to_s)
-            return false unless indices.include?(columns)
-          end
-        end
-
-        def description
-          "have index on #{@table} for #{pretty_columns}"
-        end
-
-        def failure_message
-          "expected to have index on #{@table} for #{pretty_columns}, but it didn't"
-        end
-
-        def negative_failure_message
-          "expected not to have index on #{@table} for #{pretty_columns}, but it did"
-        end
-
-        private
-
-        def pretty_columns
-          @columns.collect { |col| col.is_a?(Array) ? "[#{col.join(', ')}]" : col }.to_sentence
-        end    
-      end
-
-      # Ensures that there are DB indices on the given columns or tuples of columns.
-      # Also aliased to should_have_index for readability
-      #
-      #   it { User.should have_indices(:email, :name, [:commentable_type, :commentable_id]) }
-      #   it { User.should have_index(:age) }
-      # 
-      def have_indices(*columns)
-        Remarkable::Syntax::RSpec::HaveIndices.new(*columns)
-      end
-
-      alias :have_index :have_indices
-    end
-
-    module Shoulda
-      # Ensures that there are DB indices on the given columns or tuples of columns.
-      # Also aliased to should_have_index for readability
-      #
-      #   should_have_indices :email, :name, [:commentable_type, :commentable_id]
-      #   should_have_index :age
-      #
-      def should_have_indices(*columns)
-        table = model_class.table_name
-        indices = ::ActiveRecord::Base.connection.indexes(table).map(&:columns)
-
-        columns.each do |column|
-          it "should have index on #{table} for #{column.inspect}" do
-            columns = [column].flatten.map(&:to_s)
-            assert_contains(indices, columns).should be_true
-          end
-        end
-      end
-
-      alias_method :should_have_index, :should_have_indices
-    end
-
-  end
-end

data/lib/remarkable/active_record/macros/validations/allow_values_for.rb

@@ -1,103 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class AllowValuesFor
-        include Remarkable::Private
-        
-        def initialize(attribute, *good_values)
-          get_options!(good_values)
-
-          @attribute = attribute
-          @good_values = good_values
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            @good_values.each do |v|
-              return false unless assert_good_value(klass, @attribute, v)
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          "allow #{@attribute} to be set to #{@good_values.to_sentence}"
-        end
-
-        def failure_message
-          "expected allow #{@attribute} to be set to #{@good_values.to_sentence}, but it didn't"
-        end
-
-        def negative_failure_message
-          "expected allow #{@attribute} not to be set to #{@good_values.to_sentence}, but it did"
-        end
-      end
-
-      # Ensures that the attribute can be set to the given values.
-      #
-      # If an instance variable has been created in the setup named after the
-      # model being tested, then this method will use that.  Otherwise, it will
-      # create a new instance to test against.
-      #
-      # Example:
-      #   it { Book.should allow_values_for(:isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0") }
-      #   it { Book.should_not allow_values_for(:isbn, "bad 1", "bad 2") }
-      #
-      def allow_values_for(attribute, *good_values)
-        Remarkable::Syntax::RSpec::AllowValuesFor.new(attribute, *good_values)
-      end
-    end
-
-    module Shoulda
-      # Ensures that the attribute can be set to the given values.
-      #
-      # If an instance variable has been created in the setup named after the
-      # model being tested, then this method will use that.  Otherwise, it will
-      # create a new instance to test against.
-      #
-      # Example:
-      #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
-      #
-      def should_allow_values_for(attribute, *good_values)
-        get_options!(good_values)
-        klass = model_class
-        good_values.each do |v|
-          it "should allow #{attribute} to be set to #{v.inspect}" do
-            assert_good_value(klass, attribute, v).should be_true
-          end
-        end
-      end
-      
-      # Ensures that the attribute cannot be set to the given values
-      #
-      # If an instance variable has been created in the setup named after the
-      # model being tested, then this method will use that.  Otherwise, it will
-      # create a new instance to test against.
-      #
-      # Options:
-      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.invalid')</tt>
-      #
-      # Example:
-      #   should_not_allow_values_for :isbn, "bad 1", "bad 2"
-      #
-      def should_not_allow_values_for(attribute, *bad_values)
-        message = get_options!(bad_values, :message)
-        message ||= default_error_message(:invalid)
-        klass = model_class
-        bad_values.each do |v|
-          it "should not allow #{attribute} to be set to #{v.inspect}" do
-            assert_bad_value(klass, attribute, v, message).should be_true
-          end
-        end
-      end
-    end
-
-  end
-end