shoulda-matchers 3.0.0 → 3.0.1

data/lib/shoulda/matchers/active_record/validate_uniqueness_of_matcher.rb

@@ -412,6 +412,14 @@ module Shoulda
             if @options[:case_insensitive]
               disallows_value_of(swapcased_value, @expected_message)
             else
+              if value == swapcased_value
+                raise NonCaseSwappableValueError.create(
+                  model: @subject.class,
+                  attribute: @attribute,
+                  value: value
+                )
+              end
+
               allows_value_of(swapcased_value, @expected_message)
             end
           else
@@ -551,6 +559,33 @@ module Shoulda
         def column_for(scope)
           @subject.class.columns_hash[scope.to_s]
         end
+
+        # @private
+        class NonCaseSwappableValueError < Shoulda::Matchers::Error
+          attr_accessor :model, :attribute, :value
+
+          def message
+            Shoulda::Matchers.word_wrap <<-MESSAGE
+Your #{model.name} model has a uniqueness validation on :#{attribute} which is
+declared to be case-sensitive, but the value the uniqueness matcher used,
+#{value.inspect}, doesn't contain any alpha characters, so using it to
+to test the case-sensitivity part of the validation is ineffective. There are
+two possible solutions for this depending on what you're trying to do here:
+
+a) If you meant for the validation to be case-sensitive, then you need to give
+   the uniqueness matcher a saved instance of #{model.name} with a value for
+   :#{attribute} that contains alpha characters.
+
+b) If you meant for the validation to be case-insensitive, then you need to
+   add `case_sensitive: false` to the validation and add `case_insensitive` to
+   the matcher.
+
+For more information, please see:
+
+http://matchers.shoulda.io/docs/v#{Shoulda::Matchers::VERSION}/file.NonCaseSwappableValueError.html
+            MESSAGE
+          end
+        end
       end
     end
   end

data/lib/shoulda/matchers/util.rb

@@ -1,3 +1,5 @@
+require 'shoulda/matchers/util/word_wrap'
+
 module Shoulda
   module Matchers
     # @private

data/lib/shoulda/matchers/util/word_wrap.rb

@@ -0,0 +1,178 @@
+module Shoulda
+  module Matchers
+    # @private
+    def self.word_wrap(document)
+      Document.new(document).wrap
+    end
+
+    # @private
+    class Document
+      def initialize(document)
+        @document = document
+      end
+
+      def wrap
+        wrapped_paragraphs.map { |lines| lines.join("\n") }.join("\n\n")
+      end
+
+      protected
+
+      attr_reader :document
+
+      private
+
+      def paragraphs
+        document.split(/\n{2,}/)
+      end
+
+      def wrapped_paragraphs
+        paragraphs.map do |paragraph|
+          Paragraph.new(paragraph).wrap
+        end
+      end
+    end
+
+    # @private
+    class Text < ::String
+      LIST_ITEM_REGEXP = /\A((?:[a-z0-9]+(?:\)|\.)|\*) )/
+
+      def indented?
+        self =~ /\A[ ]+/
+      end
+
+      def list_item?
+        self =~ LIST_ITEM_REGEXP
+      end
+
+      def match_as_list_item
+        match(LIST_ITEM_REGEXP)
+      end
+    end
+
+    # @private
+    class Paragraph
+      def initialize(paragraph)
+        @paragraph = Text.new(paragraph)
+      end
+
+      def wrap
+        if paragraph.indented?
+          lines
+        elsif paragraph.list_item?
+          wrap_list_item
+        else
+          wrap_generic_paragraph
+        end
+      end
+
+      protected
+
+      attr_reader :paragraph
+
+      private
+
+      def wrap_list_item
+        wrap_lines(combine_list_item_lines(lines))
+      end
+
+      def lines
+        paragraph.split("\n").map { |line| Text.new(line) }
+      end
+
+      def combine_list_item_lines(lines)
+        lines.reduce([]) do |combined_lines, line|
+          if line.list_item?
+            combined_lines << line
+          else
+            combined_lines.last << (' ' + line).squeeze(' ')
+          end
+
+          combined_lines
+        end
+      end
+
+      def wrap_lines(lines)
+        lines.map { |line| Line.new(line).wrap }
+      end
+
+      def wrap_generic_paragraph
+        Line.new(combine_paragraph_into_one_line).wrap
+      end
+
+      def combine_paragraph_into_one_line
+        paragraph.gsub(/\n/, ' ')
+      end
+    end
+
+    # @private
+    class Line
+      TERMINAL_WIDTH = 72
+
+      def initialize(line)
+        @original_line = @line_to_wrap = Text.new(line)
+        @indentation = nil
+      end
+
+      def wrap
+        lines = []
+
+        if line_to_wrap.indented?
+          lines << line_to_wrap
+        else
+          loop do
+            new_line = (indentation || '') + line_to_wrap
+            result = wrap_line(new_line)
+            lines << result[:fitted_line].rstrip
+            @indentation ||= read_indentation
+            @line_to_wrap = result[:leftover]
+
+            if line_to_wrap.empty? || @original_line == @line_to_wrap
+              break
+            end
+          end
+        end
+
+        lines
+      end
+
+      protected
+
+      attr_reader :original_line, :line_to_wrap, :indentation
+
+      private
+
+      def read_indentation
+        match = line_to_wrap.match_as_list_item
+
+        if match
+          ' ' * match[1].length
+        else
+          ''
+        end
+      end
+
+      def wrap_line(line)
+        if line.length > TERMINAL_WIDTH
+          index = determine_where_to_break_line(line)
+          fitted_line = line[0 .. index].rstrip
+          leftover = line[index + 1 .. -1]
+        else
+          fitted_line = line
+          leftover = ''
+        end
+
+        { fitted_line: fitted_line, leftover: leftover }
+      end
+
+      def determine_where_to_break_line(line)
+        index = TERMINAL_WIDTH - 1
+
+        while line[index] !~ /\s/
+          index -= 1
+        end
+
+        index
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/version.rb

@@ -1,6 +1,6 @@
 module Shoulda
   module Matchers
     # @private
-    VERSION = '3.0.0'.freeze
+    VERSION = '3.0.1'.freeze
   end
 end

data/lib/shoulda/matchers/warn.rb

@@ -6,7 +6,7 @@ module Shoulda
     def self.warn(message)
       header = "Warning from shoulda-matchers:"
       divider = "*" * TERMINAL_MAX_WIDTH
-      wrapped_message = word_wrap(message, TERMINAL_MAX_WIDTH)
+      wrapped_message = word_wrap(message)
       full_message = [
         divider,
         [header, wrapped_message.strip].join("\n\n"),
@@ -23,14 +23,5 @@ module Shoulda
 release. Please use #{new_method} instead.
 EOT
     end
-
-    # Source: <https://www.ruby-forum.com/topic/57805>
-    # @private
-    def self.word_wrap(text, width=80)
-      text.
-        gsub(/\n+/, " ").
-        gsub( /(\S{#{width}})(?=\S)/, '\1 ' ).
-        gsub( /(.{1,#{width}})(?:\s+|$)/, "\\1\n" )
-    end
   end
 end

data/spec/acceptance_spec_helper.rb

@@ -5,20 +5,14 @@ Tests::CurrentBundle.instance.assert_appraisal!
 #---
 
 require 'rspec/core'
-require 'pry'
-require 'pry-byebug'
+
+require 'spec_helper'
 
 Dir[ File.join(File.expand_path('../support/acceptance/**/*.rb', __FILE__)) ].sort.each do |file|
   require file
 end
 
 RSpec.configure do |config|
-  config.order = :random
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
   if config.respond_to?(:infer_spec_type_from_file_location!)
     config.infer_spec_type_from_file_location!
   end
@@ -27,5 +21,3 @@ RSpec.configure do |config|
 
   config.include AcceptanceTests::Matchers
 end
-
-$VERBOSE = true

data/spec/doublespeak_spec_helper.rb

@@ -1,18 +1,2 @@
 require 'shoulda/matchers/doublespeak'
-
-PROJECT_ROOT = File.expand_path('../..', __FILE__)
-$LOAD_PATH << File.join(PROJECT_ROOT, 'lib')
-
-RSpec.configure do |config|
-  config.order = :random
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  if config.files_to_run.one?
-    config.default_formatter = 'doc'
-  end
-
-  config.mock_with :rspec
-end
+require 'spec_helper'

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+PROJECT_ROOT = File.expand_path('../..', __FILE__)
+$LOAD_PATH << File.join(PROJECT_ROOT, 'lib')
+
+require 'pry'
+require 'pry-byebug'
+
+require 'rspec'
+
+RSpec.configure do |config|
+  config.order = :random
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.mock_with :rspec
+end
+
+$VERBOSE = true

data/spec/unit/shoulda/matchers/active_model/numericality_matchers/comparison_matcher_spec.rb

@@ -283,6 +283,6 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
   end
 
   def numericality_matcher
-    double(diff_to_compare: 1)
+    double(diff_to_compare: 1, given_numeric_column?: nil)
   end
 end

data/spec/unit/shoulda/matchers/active_model/numericality_matchers/even_number_matcher_spec.rb

@@ -1,7 +1,7 @@
 require 'unit_spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::EvenNumberMatcher  do
-  subject { described_class.new(:attr) }
+  subject { described_class.new(numericality_matcher, :attr) }
 
   it_behaves_like 'a numerical submatcher'
   it_behaves_like 'a numerical type submatcher'
@@ -84,6 +84,10 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::EvenNumberMatcher
     end
   end
 
+  def numericality_matcher
+    double(:numericality_matcher, given_numeric_column?: nil)
+  end
+
   def validating_even_number(options = {})
     define_model :example, attr: :string do
       validates_numericality_of :attr, { even: true }.merge(options)
@@ -93,5 +97,4 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::EvenNumberMatcher
   def not_validating_even_number
     define_model(:example, attr: :string).new
   end
-
 end

data/spec/unit/shoulda/matchers/active_model/numericality_matchers/odd_number_matcher_spec.rb

@@ -1,7 +1,7 @@
 require 'unit_spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OddNumberMatcher  do
-  subject { described_class.new(:attr) }
+  subject { described_class.new(numericality_matcher, :attr) }
 
   it_behaves_like 'a numerical submatcher'
   it_behaves_like 'a numerical type submatcher'
@@ -84,6 +84,10 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OddNumberMatcher
     end
   end
 
+  def numericality_matcher
+    double(:numericality_matcher, given_numeric_column?: nil)
+  end
+
   def validating_odd_number(options = {})
     define_model :example, attr: :string do
       validates_numericality_of :attr, { odd: true }.merge(options)
@@ -93,5 +97,4 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OddNumberMatcher
   def not_validating_odd_number
     define_model(:example, attr: :string).new
   end
-
 end

data/spec/unit/shoulda/matchers/active_model/numericality_matchers/only_integer_matcher_spec.rb

@@ -1,7 +1,7 @@
 require 'unit_spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OnlyIntegerMatcher do
-  subject { described_class.new(:attr) }
+  subject { described_class.new(numericality_matcher, :attr) }
 
   it_behaves_like 'a numerical submatcher'
   it_behaves_like 'a numerical type submatcher'
@@ -84,6 +84,10 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OnlyIntegerMatche
     end
   end
 
+  def numericality_matcher
+    double(:numericality_matcher, given_numeric_column?: nil)
+  end
+
   def validating_only_integer(options = {})
     define_model :example, attr: :string do
       validates_numericality_of :attr, { only_integer: true }.merge(options)

data/spec/unit/shoulda/matchers/active_model/validate_inclusion_of_matcher_spec.rb

@@ -75,7 +75,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
       end
     end
 
-    context "against a float attribute" do
+    context 'against a float attribute' do
       it_behaves_like 'it supports in_array',
         possible_values: [1.0, 2.0, 3.0, 4.0, 5.0],
         zero: 0.0,
@@ -97,7 +97,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
       end
     end
 
-    context "against a decimal attribute" do
+    context 'against a decimal attribute' do
       it_behaves_like 'it supports in_array',
         possible_values: [1.0, 2.0, 3.0, 4.0, 5.0].map { |number|
           BigDecimal.new(number.to_s)
@@ -121,6 +121,72 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
       end
     end
 
+    context 'against a date attribute' do
+      today = Date.today
+
+      it_behaves_like 'it supports in_array',
+        possible_values: (1..5).map { |n| today + n },
+        reserved_outside_value: described_class::ARBITRARY_OUTSIDE_DATE
+
+      it_behaves_like 'it supports in_range',
+        possible_values: (today .. today + 5)
+
+      define_method :build_object do |options = {}, &block|
+        build_object_with_generic_attribute(
+          options.merge(column_type: :date, value: today),
+          &block
+        )
+      end
+
+      def add_outside_value_to(values)
+        values + [values.last + 1]
+      end
+    end
+
+    context 'against a datetime attribute' do
+      now = DateTime.now
+
+      it_behaves_like 'it supports in_array',
+        possible_values: (1..5).map { |n| now + n },
+        reserved_outside_value: described_class::ARBITRARY_OUTSIDE_DATETIME
+
+      it_behaves_like 'it supports in_range',
+        possible_values: (now .. now + 5)
+
+      define_method :build_object do |options = {}, &block|
+        build_object_with_generic_attribute(
+          options.merge(column_type: :datetime, value: now),
+          &block
+        )
+      end
+
+      def add_outside_value_to(values)
+        values + [values.last + 1]
+      end
+    end
+
+    context 'against a time attribute' do
+      now = Time.now
+
+      it_behaves_like 'it supports in_array',
+        possible_values: (1..5).map { |n| now + n },
+        reserved_outside_value: described_class::ARBITRARY_OUTSIDE_TIME
+
+      it_behaves_like 'it supports in_range',
+        possible_values: (now .. now + 5)
+
+      define_method :build_object do |options = {}, &block|
+        build_object_with_generic_attribute(
+          options.merge(column_type: :time, value: now),
+          &block
+        )
+      end
+
+      def add_outside_value_to(values)
+        values + [values.last + 1]
+      end
+    end
+
     context 'against a string attribute' do
       it_behaves_like 'it supports in_array',
         possible_values: %w(foo bar baz),
@@ -270,7 +336,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
     end
 
     if zero
-      it 'matches when one of the given values is a 0' do
+      it 'matches when one of the given values is a zero' do
         valid_values = possible_values + [zero]
         builder = build_object_allowing(valid_values)
         expect_to_match_on_values(builder, valid_values)
@@ -468,6 +534,28 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
   context 'for a database column' do
     include_context 'for a generic attribute'
 
+    context 'against a timestamp column' do
+      now = DateTime.now
+
+      it_behaves_like 'it supports in_array',
+        possible_values: (1..5).map { |n| now + n },
+        reserved_outside_value: described_class::ARBITRARY_OUTSIDE_DATETIME
+
+      it_behaves_like 'it supports in_range',
+        possible_values: (now .. now + 5)
+
+      define_method :build_object do |options = {}, &block|
+        build_object_with_generic_attribute(
+          options.merge(column_type: :timestamp, value: now),
+          &block
+        )
+      end
+
+      def add_outside_value_to(values)
+        values + [values.last + 1]
+      end
+    end
+
     context 'against a boolean attribute' do
       context 'which is nullable' do
         include_context 'against a boolean attribute for true and false'
@@ -527,7 +615,6 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
       end
     end
 
-
     def build_object_with_generic_attribute(options = {}, &block)
       attribute_name = :attr
       column_type = options.fetch(:column_type)