carlosbrando-remarkable 2.2.3 → 2.2.4

data/Manifest.txt

@@ -11,7 +11,7 @@ lib/remarkable/active_record/helpers.rb
 lib/remarkable/active_record/macros.rb
 lib/remarkable/active_record/macros/associations/association_matcher.rb
 lib/remarkable/active_record/macros/callbacks/callback_matcher.rb
-lib/remarkable/active_record/macros/database/column_matcher.rb
+lib/remarkable/active_record/macros/database/have_db_column_matcher.rb
 lib/remarkable/active_record/macros/database/index_matcher.rb
 lib/remarkable/active_record/macros/validations/allow_mass_assignment_of_matcher.rb
 lib/remarkable/active_record/macros/validations/ensure_value_in_list_matcher.rb

data/README.rdoc

@@ -102,10 +102,29 @@ Install the gem:
 
   sudo gem install carlosbrando-remarkable
 
-In RAILS_ROOT/config/environment.rb:
+== Installing via Rails
+
+Specify the gem dependency in your config/environment.rb file:
 
   config.gem "carlosbrando-remarkable", :lib => "remarkable", :source => "http://gems.github.com"
 
+Then run in terminal:
+
+  $ rake gems:install
+  $ rake gems:unpack
+  
+=== As a Plugin
+
+You can also install Remarkable as a plugin:
+
+  $ script/plugin install git://github.com/carlosbrando/remarkable.git
+
+Or using git submodules:
+
+  $ git submodule add git://github.com/carlosbrando/remarkable.git vendor/plugins/remarkable
+
+Note: When installed as a plugin, you need to also install the rspec and rspec-rails in your project.
+
 == Requirements
 
 * rspec >= 1.1.12

data/lib/remarkable.rb

@@ -2,7 +2,7 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module Remarkable
-  VERSION = '2.2.3'
+  VERSION = '2.2.4'
 end
 
 if ENV['RAILS_ENV'] == 'test'

data/lib/remarkable/active_record/macros/database/{column_matcher.rb → have_db_column_matcher.rb}

@@ -8,6 +8,21 @@ module Remarkable # :nodoc:
         optional  :type, :default, :precision, :limit, :scale, :sql_type
         optional  :primary, :null, :default => true
 
+        # TODO: remove it
+        def of_type(type)
+          warn "[DEPRECATION] option of_type is deprecated. Use type instead."
+          @options[:type] = type
+          self
+        end
+
+        # Method used to load all options via hash.
+        # (:type, :default, :precision, :limit, :scale, :sql_type, :primary, :null)
+        # 
+        def with_options(opts = {})
+          @options.merge!(opts)
+          self
+        end
+
         assertions :has_column?, :all_options_correct?
 
         def failure_message
@@ -62,10 +77,28 @@ module Remarkable # :nodoc:
         end
       end
 
+      # Ensures that a column of the database actually exists.
+      #
+      # Options:
+      # * <tt>type</tt> - database column types like :string, :integer, etc.
+      # 
+      # * All options available in migrations are also available here.
+      #   (.type, .default, .precision, .limit, .scale, .sql_type, .primary, .null)
+      # 
+      # * <tt>with_options</tt> - option used to load the above options via hash
+      #   (:type => :string, :primary => true, etc.)
+      #
+      # Example:
+      # it { should have_db_column(:name).type(:string) }
+      # it { should have_db_column(:age).with_options(:type => :integer) }
+      # it { should_not have_db_column(:salary) }
+      # 
       def have_db_column(column, options = {})
         ColumnMatcher.new(column, options)
       end
-      
+
+      # Alias for #have_db_column
+      # 
       def have_db_columns(*columns)
         ColumnMatcher.new(*columns)
       end

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

@@ -2,46 +2,18 @@ module Remarkable # :nodoc:
   module ActiveRecord # :nodoc:
     module Matchers # :nodoc:
 
-      # Ensures the database column has specified index.
-      #
-      # Options:
-      # * <tt>unique</tt> - 
-      #
-      # Example:
-      #   it { should have_index(:ssn).unique(true) }
-      #
-      def have_indices(*columns)
-        IndexMatcher.new(*columns)
-      end
-      alias_method :have_index, :have_indices
-
       class IndexMatcher < Remarkable::Matcher::Base
         INDEX_TYPES = { true => "unique", false => "non-unique" }
-        
-        def initialize(*columns)
-          load_options(columns)
-          @columns = columns
-        end
 
-        def unique(value = true)
-          @options[:unique] = value
-          self
-        end
+        arguments :columns
+        optional  :unique, :default => true
+
+        assertions :index_exists?, :correct_unique?
 
         def table_name=(table_name)
           @table_name = table_name
         end
 
-        def matches?(subject)
-          @subject = subject
-          @expected_uniqueness = @options[:unique] ? 'unique' : 'non-unique'
-          
-          assert_matcher_for(@columns) do |column|
-            @column = column
-            index_exists? && correct_unique?
-          end
-        end
-
         def failure_message
           "Expected to #{expectation} (#{@missing})"
         end
@@ -56,6 +28,10 @@ module Remarkable # :nodoc:
 
         protected
 
+        def after_initialize!
+          @expected_uniqueness = @options[:unique] ? 'unique' : 'non-unique'
+        end
+
         def index_exists?
           return true if matched_index
 
@@ -91,13 +67,22 @@ module Remarkable # :nodoc:
         def expectation
           "have #{index_type} index on #{table_name} for #{@column.inspect}"
         end
-        
-        def load_options(options)
-          @options = {
-            :unique => nil
-          }.merge(options.extract_options!)
-        end
+
+      end
+
+      # Ensures the database column has specified index.
+      #
+      # Options:
+      # * <tt>unique</tt> - when supplied, tests if the index is unique or not
+      #
+      # Example:
+      #   it { should have_index(:ssn).unique(true) }
+      #
+      def have_indices(*columns)
+        IndexMatcher.new(*columns)
       end
+      alias_method :have_index, :have_indices
+
     end
   end
 end

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

@@ -4,30 +4,10 @@ module Remarkable # :nodoc:
       class EnsureValueInListMatcher < Remarkable::Matcher::Base
         include Remarkable::ActiveRecord::Helpers
 
-        def initialize(attribute, behavior, *good_values)
-          @behavior = behavior
-          load_options(good_values.extract_options!)
+        arguments  :attribute, :behavior, :good_values
+        assertions :value_valid?
 
-          @attribute = attribute
-          @good_values = good_values
-        end
-
-        def matches?(subject)
-          @subject = subject
-
-          assert_matcher_for(@good_values) do |good_value|
-            @good_value = good_value
-            value_valid?
-          end &&
-          assert_matcher do
-            @good_value = 'nil'
-            allow_nil?
-          end &&
-          assert_matcher do
-            @good_value = 'blank'
-            allow_blank?
-          end
-        end
+        single_assertions :allow_blank?, :allow_nil?
 
         def description
           values = @good_values.dup
@@ -51,10 +31,8 @@ module Remarkable # :nodoc:
 
         private
 
-        def load_options(options = {})
-          @options = {
-            :message => @behavior
-          }.merge(options)
+        def default_options
+          { :message => @behavior }
         end
 
         def value_valid?

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

@@ -4,13 +4,8 @@ module Remarkable # :nodoc:
       class EnsureValueInRangeMatcher < Remarkable::Matcher::Base
         include Remarkable::ActiveRecord::Helpers
 
-        def initialize(attribute, behavior, range, *options)
-          @attribute = attribute
-          @range     = range
-          @behavior  = behavior
-          load_options(options.extract_options!)
-        end
-        
+        arguments :attribute, :behavior, :ranges
+
         def low_message(message)
           warn "[DEPRECATION] should_ensure_value_in_range.low_message is deprecated. " <<
                "Use should_validate_inclusion_of.message instead."
@@ -34,14 +29,8 @@ module Remarkable # :nodoc:
           self
         end
 
-        def matches?(subject)
-          @subject = subject
-
-          assert_matcher do
-            less_than_minimum? && accepts_minimum? && more_than_minimum? && allow_nil? &&
-            more_than_maximum? && accepts_maximum? && less_than_maximum? && allow_blank?
-          end
-        end
+        assertions :less_than_minimum?, :accepts_minimum?, :more_than_minimum?, :allow_nil?,
+                   :more_than_maximum?, :accepts_maximum?, :less_than_maximum?, :allow_blank?
 
         def description
           "ensure #{expectation}"
@@ -144,27 +133,26 @@ module Remarkable # :nodoc:
           end
         end
 
-        def load_options(options = {})
-          warn "[DEPRECATION] should_ensure_value_in_range with :low_message is deprecated. " <<
-               "Use should_validate_inclusion_of with :message instead." if options[:low_message]
-
-          warn "[DEPRECATION] should_ensure_value_in_range with :high_message is deprecated. " <<
-               "Use should_validate_inclusion_of with :message instead." if options[:high_message]
-
-          warn "[DEPRECATION] should_ensure_value_in_range is deprecated. " <<
-               "Use should_validate_inclusion_of instead." if options[:low_message].blank? && options[:high_message].blank?
-
-          @options = {
-            :low_message  => @behavior,
+        def default_options
+          { :low_message  => @behavior,
             :high_message => @behavior,
-            :message      => @behavior
-          }.merge(options)
+            :message      => @behavior }
         end
       end
 
-
       # TODO Deprecate this method, but not the matcher.
       def ensure_value_in_range(attribute, range, *options) #:nodoc:
+        hash_options = options.extract_options!
+
+        warn "[DEPRECATION] should_ensure_value_in_range with :low_message is deprecated. " <<
+             "Use should_validate_inclusion_of with :message instead." if hash_options[:low_message]
+
+        warn "[DEPRECATION] should_ensure_value_in_range with :high_message is deprecated. " <<
+             "Use should_validate_inclusion_of with :message instead." if hash_options[:high_message]
+
+        warn "[DEPRECATION] should_ensure_value_in_range is deprecated. " <<
+             "Use should_validate_inclusion_of instead." if hash_options[:low_message].blank? && hash_options[:high_message].blank?
+
         EnsureValueInRangeMatcher.new(attribute, :inclusion, range, *options)
       end
     end

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

@@ -34,10 +34,8 @@ module Remarkable # :nodoc:
         end
 
         # Receives a Hash
-        def load_options(options = {})
-          @options = {
-            :message => :accepted
-          }.merge(options)
+        def default_options
+          { :message => :accepted }
         end
 
         def expectation

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

@@ -6,24 +6,10 @@ module Remarkable # :nodoc:
 
         undef_method :allow_nil, :allow_nil?, :allow_blank, :allow_blank?
 
-        def initialize(*associations)
-          load_options(associations.extract_options!)
-          @associations = associations
-        end
-
-        def builder(value)
-          @options[:builder] = value
-          self
-        end
+        arguments :associations
+        optional :builder
 
-        def matches?(subject)
-          @subject = get_instance_of(subject)
-
-          assert_matcher_for(@associations) do |association|
-            @association = association
-            build_association? && valid?
-          end
-        end
+        assertions :build_association?, :valid?
 
         def description
           "require association #{@associations.to_sentence} to be valid"
@@ -103,11 +89,15 @@ module Remarkable # :nodoc:
           false
         end
 
-        # Receives a Hash
-        def load_options(options = {})
-          @options = {
-            :message => :invalid
-          }.merge(options)
+        # Before make the assertions, convert the subject into a instance, if
+        # it's not already.
+        #
+        def before_assert!
+          @subject = get_instance_of(@subject)
+        end
+
+        def default_options
+          { :message => :invalid }
         end
 
         def plural?

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

@@ -6,19 +6,8 @@ module Remarkable # :nodoc:
 
         undef_method :allow_nil?, :allow_nil, :allow_blank?, :allow_blank
 
-        def initialize(*attributes)
-          load_options(attributes.extract_options!)
-          @attributes = attributes
-        end
-
-        def matches?(subject)
-          @subject = get_instance_of(subject)
-
-          assert_matcher_for(@attributes) do |attribute|
-            @attribute = attribute
-            confirmed?
-          end
-        end
+        arguments :attributes
+        assertions :confirmed?
 
         def description
           "validate confirmation of #{@attributes.to_sentence}"
@@ -26,6 +15,17 @@ module Remarkable # :nodoc:
 
         private
 
+        # Before make the assertions, convert the subject into a instance, if
+        # it's not already.
+        #
+        def before_assert!
+          @subject = get_instance_of(@subject)
+        end
+
+        def default_options
+          { :message => :confirmation }
+        end
+
         def confirmed?
           confirmation_assignment = "#{@attribute}_confirmation="
 
@@ -41,12 +41,6 @@ module Remarkable # :nodoc:
           end
         end
 
-        def load_options(options = {})
-          @options = {
-            :message => :confirmation
-          }.merge(options)
-        end
-
         def expectation
           "#{@attribute} to be confirmed"
         end

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

@@ -4,18 +4,11 @@ module Remarkable # :nodoc:
       class ValidateLengthOfMatcher < Remarkable::Matcher::Base
         include Remarkable::ActiveRecord::Helpers
 
-        def initialize(attributes, range, behavior, options = {})
-          @attributes = attributes
-          @behavior   = behavior
+        arguments :behavior, :range, :attributes
+        optional  :minimum, :maximum, :short_message, :long_message
 
-          # Set the values, for example:
-          #
-          #   send(:within, 0..10)
-          #
-          send(@behavior, range)
-
-          load_options(options)
-        end
+        assertions :less_than_min_length?, :exactly_min_length?, :allow_nil?,
+                   :more_than_max_length?, :exactly_max_length?, :allow_blank?
 
         # If message is supplied, reassign it properly to :short_message
         # and :long_message. This is ActiveRecord default behavior when
@@ -31,127 +24,102 @@ module Remarkable # :nodoc:
 
         def within(range)
           @behavior = :within
-          @minimum  = range.first
-          @maximum  = range.last
+          @options[:minimum] = range.first
+          @options[:maximum] = range.last
           self
         end
         alias :in :within
 
-        def minimum(value)
-          @minimum = value
-          self
-        end
-
-        def maximum(value)
-          @maximum = value
-          self
-        end
-
         def is(value)
-          @minimum = value
-          @maximum = value
+          @options[:minimum] = value
+          @options[:maximum] = value
           self
         end
 
-        def short_message(message)
-          @options[:short_message] = message
-          @options[:message] = message # make a copy in @options[:message], for
-                                       # allow_blank and allow_nil work properly.
-          self
+        def description
+          "ensure #{expectation}"
         end
 
-        def long_message(message)
-          @options[:long_message] = message
-          self
+        def failure_message
+          "Expected #{expectation} (#{@missing})"
         end
 
-        def matches?(subject)
-          @subject = subject
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
 
-          assert_matcher_for(@attributes) do |attribute|
-            @attribute = attribute
+        private
 
-            less_than_min_length? && exactly_min_length? && allow_nil?(:message, @minimum) &&
-            more_than_max_length? && exactly_max_length? && allow_blank?(:message, @minimum)
+        def default_options
+          if @behavior == :is
+            { :short_message => :wrong_length, :long_message => :wrong_length }
+          else
+            { :short_message => :too_short, :long_message => :too_long }
           end
         end
 
-        def description
-          "ensure #{expectation}"
-        end
+        # Reassign messages properly
+        def after_initialize!
+          # Set the values, for example:
+          # send(:within, 0..10)
+          send(@behavior, @range)
 
-        def failure_message
-          "Expected #{expectation} (#{@missing})"
+          message(@options.delete(:message)) if @options[:message]
+          long_message(@options[:long_message])
+          short_message(@options[:short_message])
         end
 
-        def negative_failure_message
-          "Did not expect #{expectation}"
+        def allow_nil?
+          super(:short_message, @options[:minimum])
         end
 
-        private
+        def allow_blank?
+          super(:short_message, @options[:minimum])
+        end
 
         def less_than_min_length?
-          return true if @behavior == :maximum || @minimum <= 0
-          return true if bad?(value_for_length(@minimum - 1), :short_message, @minimum)
+          return true if @behavior == :maximum || @options[:minimum] <= 0
+          return true if bad?(value_for_length(@options[:minimum] - 1), :short_message, @options[:minimum])
 
-          @missing = "allow #{@attribute} to be less than #{@minimum} chars long"
+          @missing = "allow #{@attribute} to be less than #{@options[:minimum]} chars long"
           return false
         end
 
         def exactly_min_length?
-          return true if @behavior == :maximum || @minimum <= 0
-          return true if good?(value_for_length(@minimum), :short_message, @minimum)
+          return true if @behavior == :maximum || @options[:minimum] <= 0
+          return true if good?(value_for_length(@options[:minimum]), :short_message, @options[:minimum])
 
-          @missing = "not allow #{@attribute} to be exactly #{@minimum} chars long"
+          @missing = "not allow #{@attribute} to be exactly #{@options[:minimum]} chars long"
           return false
         end
 
         def more_than_max_length?
           return true if @behavior == :minimum
-          return true if bad?(value_for_length(@maximum + 1), :long_message, @maximum)
+          return true if bad?(value_for_length(@options[:maximum] + 1), :long_message, @options[:maximum])
 
-          @missing = "allow #{@attribute} to be more than #{@maximum} chars long"
+          @missing = "allow #{@attribute} to be more than #{@options[:maximum]} chars long"
           return false
         end
 
         def exactly_max_length?
-          return true if @behavior == :minimum || @minimum == @maximum
-          return true if good?(value_for_length(@maximum), :long_message, @maximum)
+          return true if @behavior == :minimum || @options[:minimum] == @options[:maximum]
+          return true if good?(value_for_length(@options[:maximum]), :long_message, @options[:maximum])
 
-          @missing = "not allow #{@attribute} to be exactly #{@maximum} chars long"
+          @missing = "not allow #{@attribute} to be exactly #{@options[:maximum]} chars long"
           return false
         end
 
-        def load_options(options)
-          if @behavior == :is
-            @options = {
-              :short_message => :wrong_length,
-              :long_message => :wrong_length
-            }.merge(options)
-          else
-            @options = {
-              :short_message => :too_short,
-              :long_message => :too_long
-            }.merge(options)
-          end
-
-          # Reassign messages properly
-          message(@options[:message]) if @options[:message]
-          long_message(@options[:long_message])
-          short_message(@options[:short_message])
-        end
-
         def expectation
           message = "that the length of the #{@attribute} is "
 
           message << if @behavior == :within
-            "between #{@minimum} and #{@maximum}"
+            "between #{@options[:minimum]} and #{@options[:maximum]}"
           elsif @behavior == :minimum
-            "more than #{@minimum}"
+            "more than #{@options[:minimum]}"
           elsif @behavior == :maximum
-            "less than #{@maximum}"
+            "less than #{@options[:maximum]}"
           else #:is
-            "equal to #{@minimum}"
+            "equal to #{@options[:minimum]}"
           end
 
           message << " or nil"   if @options[:allow_nil]
@@ -207,7 +175,7 @@ module Remarkable # :nodoc:
 
         [:within, :in, :maximum, :minimum, :is].each do |behavior|
           if options.key? behavior
-            matcher ||= ValidateLengthOfMatcher.new(attributes, options.delete(behavior), behavior, options)
+            matcher ||= ValidateLengthOfMatcher.new(behavior, options.delete(behavior), *(attributes << options))
           end
         end
 
@@ -227,21 +195,21 @@ module Remarkable # :nodoc:
       def ensure_length_in_range(attribute, range, options = {}) #:nodoc:
         warn "[DEPRECATION] should_ensure_length_in_range is deprecated. " <<
              "Use should_validate_length_of(#{attribute.inspect}, :in => #{range.inspect}) instead."
-        ValidateLengthOfMatcher.new([attribute], range, :within, options)
+        ValidateLengthOfMatcher.new(:within, range, attribute, options)
       end
 
       # TODO Deprecate me
       def ensure_length_at_least(attribute, range, options = {}) #:nodoc:
         warn "[DEPRECATION] should_ensure_length_at_least is deprecated. " <<
              "Use should_validate_length_of(#{attribute.inspect}, :minimum => #{range.inspect}) instead."
-        ValidateLengthOfMatcher.new([attribute], range, :minimum, options)
+        ValidateLengthOfMatcher.new(:minimum, range, attribute, options)
       end
 
       # TODO Deprecate me
       def ensure_length_is(attribute, range, options = {}) #:nodoc:
         warn "[DEPRECATION] should_ensure_length_is is deprecated. " <<
              "Use should_validate_length_of(#{attribute.inspect}, :is => #{range.inspect}) instead."
-        ValidateLengthOfMatcher.new([attribute], range, :is, options)
+        ValidateLengthOfMatcher.new(:is, range, attribute, options)
       end
     end
   end

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

@@ -6,29 +6,14 @@ module Remarkable # :nodoc:
 
         NUMERIC_COMPARISIONS = [:equal_to, :less_than, :greater_than, :less_than_or_equal_to, :greater_than_or_equal_to]
 
-        def initialize(*attributes)
-          load_options(attributes.extract_options!)
-          @attributes = attributes
-        end
+        arguments :attributes
 
         optional :only_integer, :odd, :even, :default => true
         optional :equal_to, :less_than, :greater_than, :less_than_or_equal_to, :greater_than_or_equal_to
 
-        def matches?(subject)
-          @subject = subject
-
-          assert_matcher_for(@attributes) do |attribute|
-            @attribute = attribute
-
-            only_allow_numeric_values? && allow_blank? && allow_nil? &&
-            only_integer? && allow_odd? && allow_even? && equal_to?(:equal_to) &&
-            equal_to?(:less_than, -1) && equal_to?(:greater_than, +1) &&
-            equal_to?(:less_than_or_equal_to) && equal_to?(:greater_than_or_equal_to) &&
-            more_than_maximum?(:equal_to, +1) && less_than_minimum?(:equal_to, -1) &&
-            more_than_maximum?(:less_than) && less_than_minimum?(:greater_than) &&
-            more_than_maximum?(:less_than_or_equal_to, +1) && less_than_minimum?(:greater_than_or_equal_to, -1)
-          end
-        end
+        assertions :only_allow_numeric_values?, :allow_blank?, :allow_nil?,
+                   :only_integer?, :allow_odd?, :allow_even?, :equal_to_for_each_option?,
+                   :less_than_maximum_for_each_option?, :more_than_maximum_for_each_option?
 
         def description
           default_message + "for #{@attributes.to_sentence}"
@@ -36,6 +21,27 @@ module Remarkable # :nodoc:
 
         private
 
+        # Check equal_to? for each given option
+        #
+        def equal_to_for_each_option?
+          equal_to?(:equal_to) && equal_to?(:less_than, -1) && equal_to?(:greater_than, +1) &&
+          equal_to?(:less_than_or_equal_to) && equal_to?(:greater_than_or_equal_to)
+        end
+
+        # Check more_than_maximum? for each given option
+        #
+        def more_than_maximum_for_each_option?
+          more_than_maximum?(:equal_to, +1) && more_than_maximum?(:less_than) &&
+          more_than_maximum?(:less_than_or_equal_to, +1)
+        end
+
+        # Check less_than_maximum? for each given option
+        #
+        def less_than_maximum_for_each_option?
+           less_than_minimum?(:equal_to, -1) && less_than_minimum?(:greater_than) &&
+           less_than_minimum?(:greater_than_or_equal_to, -1)
+        end
+
         def only_allow_numeric_values?
           return true if bad?("abcd")
 
@@ -111,16 +117,18 @@ module Remarkable # :nodoc:
           (valid_value_for_test / 2) * 2
         end
 
-        def load_options(options = {})
-          @options = {
+        def default_options
+          options = {
             :message => :not_a_number,
             :odd_message => :odd,
             :even_message => :even
-          }.merge(options)
+          }
 
-          NUMERIC_COMPARISIONS.map do |key|
-            @options[:"#{key}_message"] = key
+          NUMERIC_COMPARISIONS.each do |key|
+            options[:"#{key}_message"] = key
           end
+
+          options
         end
 
         # Returns the default message for each key (:odd, :even, :equal_to, ...).

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

@@ -6,24 +6,9 @@ module Remarkable # :nodoc:
 
         undef_method :allow_blank?, :allow_blank, :allow_nil
 
-        def initialize(*attributes)
-          load_options(attributes.extract_options!)
-          @attributes = attributes
-        end
-
-        def message(message)
-          @options[:message] = message
-          self
-        end
-
-        def matches?(subject)
-          @subject = subject
-
-          assert_matcher_for(@attributes) do |attribute|
-            @attribute = attribute
-            allow_nil?
-          end
-        end
+        arguments  :attributes
+        optional   :message
+        assertions :allow_nil?
 
         def description
           "require #{@attributes.to_sentence} to be set"
@@ -31,11 +16,8 @@ module Remarkable # :nodoc:
 
         private
 
-        def load_options(options)
-          @options = {
-            :message => :blank,
-            :allow_nil => false
-          }.merge(options)
+        def default_options
+          { :message => :blank, :allow_nil => false }
         end
 
         def expectation

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

@@ -4,40 +4,23 @@ module Remarkable # :nodoc:
       class ValidateUniquenessOfMatcher < Remarkable::Matcher::Base
         include Remarkable::ActiveRecord::Helpers
 
-        def initialize(*attributes)
-          load_options(attributes.extract_options!)
-          @attributes = attributes
-        end
+        arguments :attributes
+        optional :case_sensitive, :default => true
+
+        assertions :find_first_object?, :have_attribute?, :case_sensitive?,
+                   :valid_when_changing_scoped_attribute?, :find_nil_object?,
+                   :allow_nil?, :find_blank_object?, :allow_blank?
 
         def scope(scope)
           @options[:scope] = [*scope].compact
           self
         end
 
-        def case_sensitive(value = true)
-          @options[:case_sensitive] = value
-          self
-        end
-
         # TODO Deprecate this
         #
         def scoped_to(scoped)
-          warn "[DEPRECATION] should_require_unique_attributes.scoped_to is deprecated. " <<
-               "Use should_validate_uniqueness_of.scope instead."
-          @options[:scope] = [*scoped].compact
-          self
-        end
-
-        def matches?(subject)
-          @subject = get_instance_of(subject)
-
-          assert_matcher_for(@attributes) do |attribute|
-            @attribute = attribute
-
-            find_first_object? && have_attribute? && case_sensitive? &&
-            valid_when_changing_scoped_attribute? && find_nil_object? &&
-            allow_nil? && find_blank_object? && allow_blank?
-          end
+          warn "[DEPRECATION] scoped_to is deprecated. Use only scope instead."
+          scope(scoped)
         end
 
         def description
@@ -54,6 +37,26 @@ module Remarkable # :nodoc:
 
         private
 
+        # Before make the assertions, convert the subject into a instance, if
+        # it's not already.
+        #
+        def before_assert!
+          @subject = get_instance_of(@subject)
+        end
+
+        def default_options
+          { :message => :taken }
+        end
+
+        def after_initialize!
+          if @options[:scoped_to] # TODO Deprecate scoped_to
+            warn "[DEPRECATION] :scoped_to is deprecated. Use :scope instead."
+            @options[:scope] = [*@options.delete(:scoped_to)].compact
+          else
+            @options[:scope] = [*@options[:scope]].compact
+          end
+        end
+
         # Tries to find an object in the database.
         #
         # If allow_nil and/or allow_blank is given, we must find a record which
@@ -121,13 +124,17 @@ module Remarkable # :nodoc:
           return false
         end
 
-        # If :case_sensitive is given and it's true, we swap the case of the
-        # value used in have_attribute? and see if the test object is valid.
+        # If :case_sensitive is given and it's false, we swap the case of the
+        # value used in have_attribute? and see if the test object remains valid.
         #
         # If :case_sensitive is given and it's true, we swap the case of the
         # value used in have_attribute? and see if the test object is not valid.
         #
+        # This validation will only occur if the test object is a String.
+        # 
         def case_sensitive?
+          return true unless @value.is_a?(String)
+          
           message = "case sensitive when attribute is #{@attribute}"
           assert_good_or_bad_if_key(:case_sensitive, @value.swapcase, message)
         end
@@ -155,22 +162,6 @@ module Remarkable # :nodoc:
           (@existing.send(scope) || 999).next
         end
 
-        def load_options(options)
-          @options = {
-            :message => :taken
-          }.merge(options)
-
-          if options[:scoped_to] # TODO Deprecate scoped_to
-            warn "[DEPRECATION] should_require_unique_attributes with :scoped_to is deprecated. " <<
-                 "Use should_validate_uniqueness_of with :scope instead."
-            @options[:scope] = [*options[:scoped_to]].compact
-          else
-            warn "[DEPRECATION] should_require_unique_attributes is deprecated. " <<
-                 "Use should_validate_uniqueness_of instead."
-            @options[:scope] = [*options[:scope]].compact
-          end
-        end
-
         def expectation
           message = "that the #{subject_name} can be saved if "
 
@@ -215,8 +206,13 @@ module Remarkable # :nodoc:
       def validate_uniqueness_of(*attributes)
         ValidateUniquenessOfMatcher.new(*attributes)
       end
+      
       #TODO Deprecate this alias, the deprecation warning is the matcher
-      alias :require_unique_attributes :validate_uniqueness_of
+      def require_unique_attributes(*attributes)
+        warn "[DEPRECATION] should_require_unique_attributes is deprecated. " <<
+             "Use should_validate_uniqueness_of instead."
+        validate_uniqueness_of(*attributes)
+      end
     end
   end
 end

data/lib/remarkable/dsl.rb

@@ -87,7 +87,7 @@ END
           #
           #   class ValidatePresenceOfMatcher < Remarkable::Matcher::Base
           #     def initialize(*attributes)
-          #       load_options(attributes.extract_options!)
+          #       @options = default_options.merge(attributes.extract_options!)
           #       @attributes = attributes
           #     end
           #   end
@@ -134,7 +134,7 @@ END
           #   class AllowValuesForMatcher < Remarkable::Matcher::Base
           #     def initialize(attribute, *good_values)
           #       @attribute = attribute
-          #       load_options(good_values.extract_options!)
+          #       @options = default_options.merge(good_values.extract_options!)
           #       @good_values = good_values
           #     end
           #   end
@@ -152,22 +152,10 @@ END
               "@#{name} = #{name}"
             end.join("\n")
 
-            # TODO:
-            #
-            # Do:
-            #
-            #   @options = default_options.merge(#{self.loop_argument}.extract_options!)
-            #
-            # Instead of:
-            #
-            #   load_options(#{self.loop_argument}.extract_options!)
-            #
-            # And deprecate load_options.
-            #
             class_eval <<-END, __FILE__, __LINE__
 def initialize(#{args})
   #{assignments}
-  load_options(#{self.loop_argument}.extract_options!)
+  @options = default_options.merge(#{self.loop_argument}.extract_options!)
   @#{self.loop_argument} = #{self.loop_argument}
   after_initialize!
 end
@@ -204,12 +192,6 @@ END
 
       protected
 
-        # Do not overwrite this method. It's going to be deprecated.
-        #
-        def load_options(options = {})
-          @options = default_options.merge(options)
-        end
-
         # Overwrite to provide default options.
         #
         def default_options

data/rails/init.rb

@@ -1 +1 @@
-require "remarkable.rb"
+require "remarkable.rb" if ENV['RAILS_ENV'] == 'test'

data/remarkable.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{remarkable}
-  s.version = "2.2.3"
+  s.version = "2.2.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Carlos Brando", "Jos\303\251 Valim", "Diego Carrion"]
-  s.date = %q{2009-02-10}
+  s.date = %q{2009-02-12}
   s.description = %q{}
   s.email = ["eduardobrando@gmail.com", "jose.valim@gmail.com", "dc.rec1@gmail.com"]
   s.extra_rdoc_files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc"]
-  s.files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc", "Rakefile", "init.rb", "lib/remarkable.rb", "lib/remarkable/active_record/README.markdown", "lib/remarkable/active_record/active_record.rb", "lib/remarkable/active_record/helpers.rb", "lib/remarkable/active_record/macros.rb", "lib/remarkable/active_record/macros/associations/association_matcher.rb", "lib/remarkable/active_record/macros/callbacks/callback_matcher.rb", "lib/remarkable/active_record/macros/database/column_matcher.rb", "lib/remarkable/active_record/macros/database/index_matcher.rb", "lib/remarkable/active_record/macros/validations/allow_mass_assignment_of_matcher.rb", "lib/remarkable/active_record/macros/validations/ensure_value_in_list_matcher.rb", "lib/remarkable/active_record/macros/validations/ensure_value_in_range_matcher.rb", "lib/remarkable/active_record/macros/validations/have_class_methods_matcher.rb", "lib/remarkable/active_record/macros/validations/have_instance_methods_matcher.rb", "lib/remarkable/active_record/macros/validations/have_named_scope_matcher.rb", "lib/remarkable/active_record/macros/validations/have_readonly_attributes_matcher.rb", "lib/remarkable/active_record/macros/validations/protect_attributes_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_acceptance_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_associated_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_confirmation_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_exclusion_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_format_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_inclusion_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_length_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_numericality_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_presence_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_uniqueness_of_matcher.rb", "lib/remarkable/assertions.rb", "lib/remarkable/controller/README.markdown", "lib/remarkable/controller/controller.rb", "lib/remarkable/controller/helpers.rb", "lib/remarkable/controller/macros.rb", "lib/remarkable/controller/macros/assign_matcher.rb", "lib/remarkable/controller/macros/filter_params_matcher.rb", "lib/remarkable/controller/macros/metadata_matcher.rb", "lib/remarkable/controller/macros/render_with_layout_matcher.rb", "lib/remarkable/controller/macros/respond_with_content_type_matcher.rb", "lib/remarkable/controller/macros/respond_with_matcher.rb", "lib/remarkable/controller/macros/return_from_session_matcher.rb", "lib/remarkable/controller/macros/route_matcher.rb", "lib/remarkable/controller/macros/set_the_flash_to_matcher.rb", "lib/remarkable/dsl.rb", "lib/remarkable/example/example_methods.rb", "lib/remarkable/helpers.rb", "lib/remarkable/matcher_base.rb", "lib/remarkable/private_helpers.rb", "lib/remarkable/rails.rb", "rails/init.rb", "remarkable.gemspec", "script/console", "script/destroy", "script/generate", "tasks/rspec.rake"]
+  s.files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc", "Rakefile", "init.rb", "lib/remarkable.rb", "lib/remarkable/active_record/README.markdown", "lib/remarkable/active_record/active_record.rb", "lib/remarkable/active_record/helpers.rb", "lib/remarkable/active_record/macros.rb", "lib/remarkable/active_record/macros/associations/association_matcher.rb", "lib/remarkable/active_record/macros/callbacks/callback_matcher.rb", "lib/remarkable/active_record/macros/database/have_db_column_matcher.rb", "lib/remarkable/active_record/macros/database/index_matcher.rb", "lib/remarkable/active_record/macros/validations/allow_mass_assignment_of_matcher.rb", "lib/remarkable/active_record/macros/validations/ensure_value_in_list_matcher.rb", "lib/remarkable/active_record/macros/validations/ensure_value_in_range_matcher.rb", "lib/remarkable/active_record/macros/validations/have_class_methods_matcher.rb", "lib/remarkable/active_record/macros/validations/have_instance_methods_matcher.rb", "lib/remarkable/active_record/macros/validations/have_named_scope_matcher.rb", "lib/remarkable/active_record/macros/validations/have_readonly_attributes_matcher.rb", "lib/remarkable/active_record/macros/validations/protect_attributes_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_acceptance_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_associated_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_confirmation_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_exclusion_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_format_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_inclusion_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_length_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_numericality_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_presence_of_matcher.rb", "lib/remarkable/active_record/macros/validations/validate_uniqueness_of_matcher.rb", "lib/remarkable/assertions.rb", "lib/remarkable/controller/README.markdown", "lib/remarkable/controller/controller.rb", "lib/remarkable/controller/helpers.rb", "lib/remarkable/controller/macros.rb", "lib/remarkable/controller/macros/assign_matcher.rb", "lib/remarkable/controller/macros/filter_params_matcher.rb", "lib/remarkable/controller/macros/metadata_matcher.rb", "lib/remarkable/controller/macros/render_with_layout_matcher.rb", "lib/remarkable/controller/macros/respond_with_content_type_matcher.rb", "lib/remarkable/controller/macros/respond_with_matcher.rb", "lib/remarkable/controller/macros/return_from_session_matcher.rb", "lib/remarkable/controller/macros/route_matcher.rb", "lib/remarkable/controller/macros/set_the_flash_to_matcher.rb", "lib/remarkable/dsl.rb", "lib/remarkable/example/example_methods.rb", "lib/remarkable/helpers.rb", "lib/remarkable/matcher_base.rb", "lib/remarkable/private_helpers.rb", "lib/remarkable/rails.rb", "rails/init.rb", "remarkable.gemspec", "script/console", "script/destroy", "script/generate", "tasks/rspec.rake"]
   s.has_rdoc = true
   s.homepage = %q{http://www.nomedojogo.com/2008/11/18/shoulda-for-rspec-is-remarkable/}
   s.post_install_message = %q{PostInstall.txt}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: carlosbrando-remarkable
 version: !ruby/object:Gem::Version 
-  version: 2.2.3
+  version: 2.2.4
 platform: ruby
 authors: 
 - Carlos Brando
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-10 00:00:00 -08:00
+date: 2009-02-12 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -78,7 +78,7 @@ files:
 - lib/remarkable/active_record/macros.rb
 - lib/remarkable/active_record/macros/associations/association_matcher.rb
 - lib/remarkable/active_record/macros/callbacks/callback_matcher.rb
-- lib/remarkable/active_record/macros/database/column_matcher.rb
+- lib/remarkable/active_record/macros/database/have_db_column_matcher.rb
 - lib/remarkable/active_record/macros/database/index_matcher.rb
 - lib/remarkable/active_record/macros/validations/allow_mass_assignment_of_matcher.rb
 - lib/remarkable/active_record/macros/validations/ensure_value_in_list_matcher.rb