shoulda-matchers 3.1.0 → 5.2.0

data/lib/shoulda/matchers/rails_shim.rb

@@ -1,70 +1,191 @@
 module Shoulda
   module Matchers
     # @private
-    class RailsShim
-      def self.verb_for_update
-        if action_pack_gte_4_1?
+    module RailsShim # rubocop:disable Metrics/ModuleLength
+      class << self
+        def action_pack_version
+          Gem::Version.new(::ActionPack::VERSION::STRING)
+        rescue NameError
+          Gem::Version.new('0')
+        end
+
+        def active_record_gte_6?
+          Gem::Requirement.new('>= 6').satisfied_by?(active_record_version)
+        end
+
+        def active_record_version
+          Gem::Version.new(::ActiveRecord::VERSION::STRING)
+        rescue NameError
+          Gem::Version.new('0')
+        end
+
+        def active_model_version
+          Gem::Version.new(::ActiveModel::VERSION::STRING)
+        rescue NameError
+          Gem::Version.new('0')
+        end
+
+        def active_model_gte_7?
+          Gem::Requirement.new('>= 7').satisfied_by?(active_model_version)
+        end
+
+        def active_model_lt_7?
+          Gem::Requirement.new('< 7').satisfied_by?(active_model_version)
+        end
+
+        def generate_validation_message(
+          record,
+          attribute,
+          type,
+          model_name,
+          options
+        )
+          if record && record.errors.respond_to?(:generate_message)
+            record.errors.generate_message(attribute.to_sym, type, options)
+          else
+            simply_generate_validation_message(
+              attribute,
+              type,
+              model_name,
+              options,
+            )
+          end
+        rescue RangeError
+          simply_generate_validation_message(
+            attribute,
+            type,
+            model_name,
+            options,
+          )
+        end
+
+        def serialized_attributes_for(model)
+          attribute_types_for(model).
+            inject({}) do |hash, (attribute_name, attribute_type)|
+              if attribute_type.is_a?(::ActiveRecord::Type::Serialized)
+                hash.merge(attribute_name => attribute_type.coder)
+              else
+                hash
+              end
+            end
+        rescue NotImplementedError
+          {}
+        end
+
+        def attribute_serialization_coder_for(model, attribute_name)
+          serialized_attributes_for(model)[attribute_name.to_s]
+        end
+
+        def verb_for_update
           :patch
-        else
-          :put
         end
-      end
 
-      def self.type_cast_default_for(model, column)
-        if model.respond_to?(:column_defaults)
-          # Rails 4.2
-          model.column_defaults[column.name]
-        else
-          column.default
+        def parent_of(mod)
+          if mod.respond_to?(:module_parent)
+            mod.module_parent
+          else
+            mod.parent
+          end
         end
-      end
 
-      def self.serialized_attributes_for(model)
-        if defined?(::ActiveRecord::Type::Serialized)
-          # Rails 5+
-          model.columns.select do |column|
-            column.cast_type.is_a?(::ActiveRecord::Type::Serialized)
-          end.inject({}) do |hash, column|
-            hash[column.name.to_s] = column.cast_type.coder
-            hash
+        def has_secure_password?(record, attribute_name)
+          if secure_password_module
+            attribute_name == :password &&
+              record.class.ancestors.include?(secure_password_module)
+          else
+            record.respond_to?("authenticate_#{attribute_name}")
           end
-        else
-          model.serialized_attributes
         end
-      end
 
-      def self.generate_validation_message(record, attribute, type, model_name, options)
-        if record && record.errors.respond_to?(:generate_message)
-          record.errors.generate_message(attribute.to_sym, type, options)
-        else
-          simply_generate_validation_message(attribute, type, model_name, options)
+        def digestible_attributes_in(record)
+          record.methods.inject([]) do |array, method_name|
+            match = method_name.to_s.match(
+              /\A(\w+)_(?:confirmation|digest)=\Z/,
+            )
+
+            if match
+              array.concat([match[1].to_sym])
+            else
+              array
+            end
+          end
         end
-      rescue RangeError
-        simply_generate_validation_message(attribute, type, model_name, options)
-      end
 
-      def self.simply_generate_validation_message(attribute, type, model_name, options)
-        default_translation_keys = [
-          :"activerecord.errors.models.#{model_name}.#{type}",
-          :"activerecord.errors.messages.#{type}",
-          :"errors.attributes.#{attribute}.#{type}",
-          :"errors.messages.#{type}"
-        ]
-        primary_translation_key = :"activerecord.errors.models.#{model_name}.attributes.#{attribute}.#{type}"
-        translate_options = { default: default_translation_keys }.merge(options)
-        I18n.translate(primary_translation_key, translate_options)
-      end
+        def secure_password_module
+          ::ActiveModel::SecurePassword::InstanceMethodsOnActivation
+        rescue NameError
+          nil
+        end
 
-      def self.active_record_major_version
-        ::ActiveRecord::VERSION::MAJOR
-      end
+        def attribute_types_for(model)
+          if model.respond_to?(:attribute_types)
+            model.attribute_types
+          elsif model.respond_to?(:type_for_attribute)
+            model.columns.inject({}) do |hash, column|
+              key = column.name.to_s
+              value = model.type_for_attribute(column.name)
+              hash.merge(key => value)
+            end
+          else
+            raise NotImplementedError
+          end
+        end
 
-      def self.action_pack_gte_4_1?
-        Gem::Requirement.new('>= 4.1').satisfied_by?(action_pack_version)
-      end
+        def attribute_type_for(model, attribute_name)
+          attribute_types_for(model)[attribute_name.to_s]
+        rescue NotImplementedError
+          if model.respond_to?(:type_for_attribute)
+            model.type_for_attribute(attribute_name)
+          else
+            FakeAttributeType.new(model, attribute_name)
+          end
+        end
 
-      def self.action_pack_version
-        Gem::Version.new(::ActionPack::VERSION::STRING)
+        def supports_full_attributes_api?(model)
+          defined?(::ActiveModel::Attributes) &&
+            model.respond_to?(:attribute_types)
+        end
+
+        private
+
+        def simply_generate_validation_message(
+          attribute,
+          type,
+          model_name,
+          options
+        )
+          default_translation_keys = [
+            :"activemodel.errors.models.#{model_name}.attributes.#{attribute}
+              .#{type}",
+            :"activemodel.errors.models.#{model_name}.#{type}",
+            :"activemodel.errors.messages.#{type}",
+            :"activerecord.errors.models.#{model_name}.attributes.#{attribute}
+              .#{type}",
+            :"activerecord.errors.models.#{model_name}.#{type}",
+            :"activerecord.errors.messages.#{type}",
+            :"errors.attributes.#{attribute}.#{type}",
+            :"errors.messages.#{type}",
+          ]
+          primary_translation_key = default_translation_keys.shift
+          translate_options =
+            { default: default_translation_keys }.merge(options)
+          I18n.translate(primary_translation_key, translate_options)
+        end
+
+        class FakeAttributeType
+          def initialize(model, attribute_name)
+            @model = model
+            @attribute_name = attribute_name
+          end
+
+          def coder
+            nil
+          end
+
+          private
+
+          attr_reader :model, :attribute_name
+        end
       end
     end
   end

data/lib/shoulda/matchers/routing.rb

@@ -2,8 +2,8 @@ module Shoulda
   module Matchers
     # @private
     module Routing
-      def route(method, path)
-        ActionController::RouteMatcher.new(method, path, self)
+      def route(method, path, port: nil)
+        ActionController::RouteMatcher.new(self, method, path, port: port)
       end
     end
   end

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

@@ -1,10 +1,16 @@
 module Shoulda
   module Matchers
     # @private
-    def self.word_wrap(document, options = {})
-      Document.new(document, options).wrap
+    module WordWrap
+      TERMINAL_WIDTH = 72
+
+      def word_wrap(document, options = {})
+        Document.new(document, **options).wrap
+      end
     end
 
+    extend WordWrap
+
     # @private
     class Document
       def initialize(document, indent: 0)
@@ -35,10 +41,10 @@ module Shoulda
 
     # @private
     class Text < ::String
-      LIST_ITEM_REGEXP = /\A((?:[a-z0-9]+(?:\)|\.)|\*) )/
+      LIST_ITEM_REGEXP = /\A((?:[a-z0-9]+(?:\)|\.)|\*) )/.freeze
 
       def indented?
-        self =~ /\A[ ]+/
+        self =~ /\A +/
       end
 
       def list_item?
@@ -82,11 +88,11 @@ module Shoulda
       end
 
       def combine_list_item_lines(lines)
-        lines.reduce([]) do |combined_lines, line|
+        lines.inject([]) do |combined_lines, line|
           if line.list_item?
             combined_lines << line
           else
-            combined_lines.last << (' ' + line).squeeze(' ')
+            combined_lines.last << (" #{line}").squeeze(' ')
           end
 
           combined_lines
@@ -108,8 +114,7 @@ module Shoulda
 
     # @private
     class Line
-      TERMINAL_WIDTH = 72
-      OFFSETS = { left: -1, right: +1 }
+      OFFSETS = { left: -1, right: +1 }.freeze
 
       def initialize(line, indent: 0)
         @indent = indent
@@ -164,10 +169,10 @@ module Shoulda
         end
       end
 
-      def wrap_line(line, direction: :left)
+      def wrap_line(line)
         index = nil
 
-        if line.length > TERMINAL_WIDTH
+        if line.length > Shoulda::Matchers::WordWrap::TERMINAL_WIDTH
           index = determine_where_to_break_line(line, direction: :left)
 
           if index == -1
@@ -180,7 +185,7 @@ module Shoulda
           leftover = ''
         else
           fitted_line = line[0..index].rstrip
-          leftover = line[index + 1 .. -1]
+          leftover = line[index + 1..]
         end
 
         { fitted_line: fitted_line, leftover: leftover }
@@ -188,7 +193,7 @@ module Shoulda
 
       def determine_where_to_break_line(line, args)
         direction = args.fetch(:direction)
-        index = TERMINAL_WIDTH
+        index = Shoulda::Matchers::WordWrap::TERMINAL_WIDTH
         offset = OFFSETS.fetch(direction)
 
         while line[index] !~ /\s/ && (0...line.length).cover?(index)

data/lib/shoulda/matchers/util.rb

@@ -4,9 +4,13 @@ module Shoulda
   module Matchers
     # @private
     module Util
+      MAXIMUM_LENGTH_OF_VALUE_TO_DISPLAY = 500
+
       def self.deconstantize(path)
-        if defined?(ActiveSupport::Inflector) &&
+        if (
+          defined?(ActiveSupport::Inflector) &&
           ActiveSupport::Inflector.respond_to?(:deconstantize)
+        )
           ActiveSupport::Inflector.deconstantize(path)
         else
           path.to_s[0...(path.to_s.rindex('::') || 0)]
@@ -14,8 +18,10 @@ module Shoulda
       end
 
       def self.safe_constantize(camel_cased_word)
-        if defined?(ActiveSupport::Inflector) &&
+        if (
+          defined?(ActiveSupport::Inflector) &&
           ActiveSupport::Inflector.respond_to?(:safe_constantize)
+        )
           ActiveSupport::Inflector.safe_constantize(camel_cased_word)
         else
           begin
@@ -27,12 +33,14 @@ module Shoulda
       end
 
       def self.indent(string, width)
+        return if !string
+
         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
+        if next_word =~ /\A[aeiou]/i && next_word != 'unique'
           "an #{next_word}"
         else
           "a #{next_word}"
@@ -40,7 +48,19 @@ module Shoulda
       end
 
       def self.inspect_value(value)
-        "‹#{value.inspect}›"
+        case value
+        when Hash
+          inspect_hash(value)
+        when Range
+          inspect_range(value)
+        else
+          inspected_value = value.inspect
+          if inspected_value.length > MAXIMUM_LENGTH_OF_VALUE_TO_DISPLAY
+            "‹#{inspected_value[0, MAXIMUM_LENGTH_OF_VALUE_TO_DISPLAY]}...›"
+          else
+            "‹#{inspected_value}›"
+          end
+        end
       end
 
       def self.inspect_values(values)
@@ -51,6 +71,20 @@ module Shoulda
         "#{inspect_value(range.first)} to #{inspect_value(range.last)}"
       end
 
+      def self.inspect_hash(hash)
+        output = '‹{'
+
+        output << hash.map { |key, value|
+          if key.is_a?(Symbol)
+            "#{key}: #{value.inspect}"
+          else
+            "#{key.inspect} => #{value.inspect}"
+          end
+        }.join(', ')
+
+        output << '}›'
+      end
+
       def self.dummy_value_for(column_type, array: false)
         if array
           [dummy_value_for(column_type, array: false)]
@@ -63,7 +97,7 @@ module Shoulda
           when :datetime, :timestamp
             DateTime.new(2100, 1, 1)
           when :time
-            Time.new(2100, 1, 1)
+            Time.new(2000, 1, 1)
           when :uuid
             SecureRandom.uuid
           when :boolean

data/lib/shoulda/matchers/version.rb

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

data/lib/shoulda/matchers/warn.rb

@@ -1,16 +1,17 @@
 module Shoulda
   module Matchers
+    # @private
     TERMINAL_MAX_WIDTH = 72
 
     # @private
     def self.warn(message)
-      header = "Warning from shoulda-matchers:"
-      divider = "*" * TERMINAL_MAX_WIDTH
+      header = 'Warning from shoulda-matchers:'
+      divider = '*' * TERMINAL_MAX_WIDTH
       wrapped_message = word_wrap(message)
       full_message = [
         divider,
         [header, wrapped_message.strip].join("\n\n"),
-        divider
+        divider,
       ].join("\n")
 
       Kernel.warn(full_message)

data/shoulda-matchers.gemspec

@@ -2,22 +2,40 @@ $LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
 require 'shoulda/matchers/version'
 
 Gem::Specification.new do |s|
-  s.name        = "shoulda-matchers"
+  s.name        = 'shoulda-matchers'
   s.version     = Shoulda::Matchers::VERSION.dup
-  s.authors     = ["Tammer Saleh", "Joe Ferris", "Ryan McGeary", "Dan Croak",
-                   "Matt Jankowski", "Stafford Brunk", "Elliot Winkler"]
-  s.date        = Time.now.strftime("%Y-%m-%d")
-  s.email       = "support@thoughtbot.com"
-  s.homepage    = "http://thoughtbot.com/community/"
-  s.summary     = "Making tests easy on the fingers and eyes"
-  s.license     = "MIT"
-  s.description = "Making tests easy on the fingers and eyes"
+  s.authors     = [
+    'Tammer Saleh',
+    'Joe Ferris',
+    'Ryan McGeary',
+    'Dan Croak',
+    'Matt Jankowski',
+    'Stafford Brunk',
+    'Elliot Winkler',
+  ]
+  s.date        = Time.now.strftime('%Y-%m-%d')
+  s.email       = 'support@thoughtbot.com'
+  s.homepage    = 'https://matchers.shoulda.io/'
+  s.summary     = 'Simple one-liner tests for common Rails functionality'
+  s.license     = 'MIT'
+  s.description = <<~DESC.tr("\n", ' ').squeeze(' ')
+    Shoulda Matchers provides RSpec- and Minitest-compatible one-liners to test
+    common Rails functionality that, if written by hand, would be much
+    longer, more complex, and error-prone.
+  DESC
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.metadata = {
+    'bug_tracker_uri' => 'https://github.com/thoughtbot/shoulda-matchers/issues',
+    'changelog_uri' => 'https://github.com/thoughtbot/shoulda-matchers/blob/main/CHANGELOG.md',
+    'documentation_uri' => 'https://matchers.shoulda.io/docs',
+    'homepage_uri' => 'https://matchers.shoulda.io',
+    'source_code_uri' => 'https://github.com/thoughtbot/shoulda-matchers',
+  }
 
-  s.required_ruby_version = '>= 2.0.0'
-  s.add_dependency('activesupport', '>= 4.0.0')
+  s.files = Dir['{docs,lib}/**/*', 'README.md', 'LICENSE',
+    'shoulda-matchers.gemspec']
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 2.6.0'
+  s.add_dependency('activesupport', '>= 5.2.0')
 end