shoulda-matchers 3.0.1 → 3.1.0

data/lib/shoulda/matchers/util.rb

@@ -30,6 +30,49 @@ module Shoulda
         indentation = ' ' * width
         string.split(/[\n\r]/).map { |line| indentation + line }.join("\n")
       end
+
+      def self.a_or_an(next_word)
+        if next_word =~ /\A[aeiou]/i
+          "an #{next_word}"
+        else
+          "a #{next_word}"
+        end
+      end
+
+      def self.inspect_value(value)
+        "‹#{value.inspect}›"
+      end
+
+      def self.inspect_values(values)
+        values.map { |value| inspect_value(value) }
+      end
+
+      def self.inspect_range(range)
+        "#{inspect_value(range.first)} to #{inspect_value(range.last)}"
+      end
+
+      def self.dummy_value_for(column_type, array: false)
+        if array
+          [dummy_value_for(column_type, array: false)]
+        else
+          case column_type
+          when :integer
+            0
+          when :date
+            Date.new(2100, 1, 1)
+          when :datetime, :timestamp
+            DateTime.new(2100, 1, 1)
+          when :time
+            Time.new(2100, 1, 1)
+          when :uuid
+            SecureRandom.uuid
+          when :boolean
+            true
+          else
+            'dummy value'
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,14 +1,15 @@
 module Shoulda
   module Matchers
     # @private
-    def self.word_wrap(document)
-      Document.new(document).wrap
+    def self.word_wrap(document, options = {})
+      Document.new(document, options).wrap
     end
 
     # @private
     class Document
-      def initialize(document)
+      def initialize(document, indent: 0)
         @document = document
+        @indent = indent
       end
 
       def wrap
@@ -17,7 +18,7 @@ module Shoulda
 
       protected
 
-      attr_reader :document
+      attr_reader :document, :indent
 
       private
 
@@ -27,7 +28,7 @@ module Shoulda
 
       def wrapped_paragraphs
         paragraphs.map do |paragraph|
-          Paragraph.new(paragraph).wrap
+          Paragraph.new(paragraph, indent: indent).wrap
         end
       end
     end
@@ -51,8 +52,9 @@ module Shoulda
 
     # @private
     class Paragraph
-      def initialize(paragraph)
+      def initialize(paragraph, indent: 0)
         @paragraph = Text.new(paragraph)
+        @indent = indent
       end
 
       def wrap
@@ -67,7 +69,7 @@ module Shoulda
 
       protected
 
-      attr_reader :paragraph
+      attr_reader :paragraph, :indent
 
       private
 
@@ -92,11 +94,11 @@ module Shoulda
       end
 
       def wrap_lines(lines)
-        lines.map { |line| Line.new(line).wrap }
+        lines.map { |line| Line.new(line, indent: indent).wrap }
       end
 
       def wrap_generic_paragraph
-        Line.new(combine_paragraph_into_one_line).wrap
+        Line.new(combine_paragraph_into_one_line, indent: indent).wrap
       end
 
       def combine_paragraph_into_one_line
@@ -107,72 +109,98 @@ module Shoulda
     # @private
     class Line
       TERMINAL_WIDTH = 72
+      OFFSETS = { left: -1, right: +1 }
 
-      def initialize(line)
+      def initialize(line, indent: 0)
+        @indent = indent
         @original_line = @line_to_wrap = Text.new(line)
-        @indentation = nil
+        @indentation = ' ' * indent
+        @indentation_read = false
       end
 
       def wrap
-        lines = []
-
         if line_to_wrap.indented?
-          lines << line_to_wrap
+          [line_to_wrap]
         else
+          lines = []
+
           loop do
+            @previous_line_to_wrap = line_to_wrap
             new_line = (indentation || '') + line_to_wrap
             result = wrap_line(new_line)
-            lines << result[:fitted_line].rstrip
-            @indentation ||= read_indentation
+            lines << normalize_whitespace(result[:fitted_line])
+
+            unless @indentation_read
+              @indentation = read_indentation
+              @indentation_read = true
+            end
+
             @line_to_wrap = result[:leftover]
 
-            if line_to_wrap.empty? || @original_line == @line_to_wrap
+            if line_to_wrap.to_s.empty? || previous_line_to_wrap == line_to_wrap
               break
             end
           end
-        end
 
-        lines
+          lines
+        end
       end
 
       protected
 
-      attr_reader :original_line, :line_to_wrap, :indentation
+      attr_reader :indent, :original_line, :line_to_wrap, :indentation,
+        :previous_line_to_wrap
 
       private
 
       def read_indentation
+        initial_indentation = ' ' * indent
         match = line_to_wrap.match_as_list_item
 
         if match
-          ' ' * match[1].length
+          initial_indentation + (' ' * match[1].length)
         else
-          ''
+          initial_indentation
         end
       end
 
-      def wrap_line(line)
+      def wrap_line(line, direction: :left)
+        index = nil
+
         if line.length > TERMINAL_WIDTH
-          index = determine_where_to_break_line(line)
-          fitted_line = line[0 .. index].rstrip
-          leftover = line[index + 1 .. -1]
-        else
+          index = determine_where_to_break_line(line, direction: :left)
+
+          if index == -1
+            index = determine_where_to_break_line(line, direction: :right)
+          end
+        end
+
+        if index.nil? || index == -1
           fitted_line = line
           leftover = ''
+        else
+          fitted_line = line[0..index].rstrip
+          leftover = line[index + 1 .. -1]
         end
 
         { fitted_line: fitted_line, leftover: leftover }
       end
 
-      def determine_where_to_break_line(line)
-        index = TERMINAL_WIDTH - 1
+      def determine_where_to_break_line(line, args)
+        direction = args.fetch(:direction)
+        index = TERMINAL_WIDTH
+        offset = OFFSETS.fetch(direction)
 
-        while line[index] !~ /\s/
-          index -= 1
+        while line[index] !~ /\s/ && (0...line.length).cover?(index)
+          index += offset
         end
 
         index
       end
+
+      def normalize_whitespace(string)
+        indentation + string.strip.squeeze(' ')
+      end
     end
   end
 end

data/lib/shoulda/matchers/version.rb

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

data/script/update_gem_in_all_appraisals

@@ -5,7 +5,7 @@ gem="$1"
 
 update-gem-for-version() {
   local version="$1"
-  (export RBENV_VERSION=$version; bundle update "$gem" && bundle exec appraisal update "$gem")
+  (export RBENV_VERSION=$version; bundle update "$gem"; bundle exec appraisal update "$gem")
 }
 
 for version in $SUPPORTED_VERSIONS; do

data/script/update_gems_in_all_appraisals

@@ -4,7 +4,7 @@ SUPPORTED_VERSIONS=$(<script/SUPPORTED_VERSIONS)
 
 update-gems-for-version() {
   local version="$1"
-  (export RBENV_VERSION=$version; bundle update "${@:2}" && bundle exec appraisal update "${@:2}")
+  (export RBENV_VERSION=$version; bundle update "${@:2}"; bundle exec appraisal update "${@:2}")
 }
 
 for version in $SUPPORTED_VERSIONS; do

data/spec/acceptance/multiple_libraries_integration_spec.rb

@@ -25,6 +25,7 @@ describe 'shoulda-matchers integrates with multiple libraries' do
 
     add_rspec_file 'spec/models/user_spec.rb', <<-FILE
       describe User do
+        subject { User.new(name: "John Smith") }
         it { should validate_presence_of(:name) }
         it { should validate_uniqueness_of(:name) }
       end
@@ -43,9 +44,11 @@ describe 'shoulda-matchers integrates with multiple libraries' do
     it 'allows the use of matchers from both libraries' do
       result = run_rspec_suite
       expect(result).to have_output('2 examples, 0 failures')
-      expect(result).to have_output('should require name to be set')
       expect(result).to have_output(
-        'should require case sensitive unique value for name'
+        'should validate that :name cannot be empty/falsy'
+      )
+      expect(result).to have_output(
+        'should validate that :name is case-sensitively unique'
       )
     end
   end

data/spec/acceptance/rails_integration_spec.rb

@@ -124,7 +124,9 @@ describe 'shoulda-matchers integrates with Rails' do
     result = run_n_unit_test_suite
 
     expect(result).to indicate_that_tests_were_run(unit: 1, functional: 1)
-    expect(result).to have_output('User should require name to be set')
+    expect(result).to have_output(
+      'User should validate that :name cannot be empty/falsy'
+    )
     expect(result).to have_output('should respond with 200')
   end
 
@@ -146,7 +148,9 @@ describe 'shoulda-matchers integrates with Rails' do
     result = run_rspec_suite
 
     expect(result).to have_output('2 examples, 0 failures')
-    expect(result).to have_output('should require name to be set')
+    expect(result).to have_output(
+      'should validate that :name cannot be empty/falsy'
+    )
     expect(result).to have_output('should respond with 200')
   end
 end

data/spec/spec_helper.rb

@@ -13,9 +13,7 @@ RSpec.configure do |config|
     c.syntax = :expect
   end
 
-  if config.files_to_run.one?
-    config.default_formatter = 'doc'
-  end
+  config.default_formatter = 'doc'
 
   config.mock_with :rspec
 end

data/spec/support/acceptance/helpers/step_helpers.rb

@@ -18,6 +18,7 @@ module AcceptanceTests
     end
 
     def create_generic_bundler_project
+      fs.clean
       fs.create
       run_command! 'bundle init'
     end
@@ -61,7 +62,9 @@ module AcceptanceTests
     end
 
     def create_rails_application
-      command = "bundle exec rails new #{fs.project_directory} --skip-bundle"
+      fs.clean
+
+      command = "bundle exec rails new #{fs.project_directory} --skip-bundle --no-rc"
 
       run_command!(command) do |runner|
         runner.directory = nil

data/spec/support/tests/current_bundle.rb

@@ -8,21 +8,33 @@ module Tests
     include Singleton
 
     def assert_appraisal!
-      unless appraisal?
+      unless appraisal_in_use?
         message = <<EOT
 
 
 Please run tests starting with `appraisal <appraisal_name>`.
-Possible appraisals are: #{possible_appraisals}
+Possible appraisals are: #{available_appraisals}
 
 EOT
         raise AppraisalNotSpecified, message
       end
     end
 
+    def appraisal_in_use?
+      path.dirname == root.join('gemfiles')
+    end
+
+    def current_or_latest_appraisal
+      current_appraisal || latest_appraisal
+    end
+
+    def latest_appraisal
+      available_appraisals.sort.last
+    end
+
     private
 
-    def possible_appraisals
+    def available_appraisals
       appraisals = []
 
       Appraisal::File.each do |appraisal|
@@ -32,12 +44,14 @@ EOT
       appraisals
     end
 
-    def path
-      Bundler.default_gemfile
+    def current_appraisal
+      if appraisal_in_use?
+        File.basename(path, ".gemfile")
+      end
     end
 
-    def appraisal?
-      path.dirname == root.join('gemfiles')
+    def path
+      Bundler.default_gemfile
     end
 
     def root

data/spec/support/unit/active_record/create_table.rb

@@ -0,0 +1,54 @@
+module UnitTests
+  module ActiveRecord
+    class CreateTable
+      def self.call(table_name, columns)
+        new(table_name, columns).call
+      end
+
+      def initialize(table_name, columns)
+        @table_name = table_name
+        @columns = columns
+      end
+
+      def call
+        if columns.key?(:id) && columns[:id] == false
+          columns.delete(:id)
+          UnitTests::ModelBuilder.create_table(
+            table_name,
+            id: false,
+            &method(:add_columns_to_table)
+          )
+        else
+          UnitTests::ModelBuilder.create_table(
+            table_name,
+            &method(:add_columns_to_table)
+          )
+        end
+      end
+
+      protected
+
+      attr_reader :table_name, :columns
+
+      private
+
+      def add_columns_to_table(table)
+        columns.each do |column_name, column_specification|
+          add_column_to_table(table, column_name, column_specification)
+        end
+      end
+
+      def add_column_to_table(table, column_name, column_specification)
+        if column_specification.is_a?(Hash)
+          column_type = column_specification.fetch(:type)
+          column_options = column_specification.fetch(:options, {})
+        else
+          column_type = column_specification
+          column_options = {}
+        end
+
+        table.column(column_name, column_type, column_options)
+      end
+    end
+  end
+end