activesupport 6.1.7.2 → 7.0.6

data/lib/active_support/core_ext/object/try.rb

@@ -3,32 +3,32 @@
 require "delegate"
 
 module ActiveSupport
-  module Tryable #:nodoc:
-    def try(method_name = nil, *args, &b)
-      if method_name.nil? && block_given?
-        if b.arity == 0
-          instance_eval(&b)
+  module Tryable # :nodoc:
+    def try(*args, &block)
+      if args.empty? && block_given?
+        if block.arity == 0
+          instance_eval(&block)
         else
           yield self
         end
-      elsif respond_to?(method_name)
-        public_send(method_name, *args, &b)
+      elsif respond_to?(args.first)
+        public_send(*args, &block)
       end
     end
-    ruby2_keywords(:try) if respond_to?(:ruby2_keywords, true)
+    ruby2_keywords(:try)
 
-    def try!(method_name = nil, *args, &b)
-      if method_name.nil? && block_given?
-        if b.arity == 0
-          instance_eval(&b)
+    def try!(*args, &block)
+      if args.empty? && block_given?
+        if block.arity == 0
+          instance_eval(&block)
         else
           yield self
         end
       else
-        public_send(method_name, *args, &b)
+        public_send(*args, &block)
       end
     end
-    ruby2_keywords(:try!) if respond_to?(:ruby2_keywords, true)
+    ruby2_keywords(:try!)
   end
 end
 
@@ -39,7 +39,7 @@ class Object
   # :method: try
   #
   # :call-seq:
-  #   try(*a, &b)
+  #   try(*args, &block)
   #
   # Invokes the public method whose name goes as first argument just like
   # +public_send+ does, except that if the receiver does not respond to it the
@@ -104,7 +104,7 @@ class Object
   # :method: try!
   #
   # :call-seq:
-  #   try!(*a, &b)
+  #   try!(*args, &block)
   #
   # Same as #try, but raises a +NoMethodError+ exception if the receiver is
   # not +nil+ and does not implement the tried method.
@@ -121,7 +121,7 @@ class Delegator
   # :method: try
   #
   # :call-seq:
-  #   try(a*, &b)
+  #   try(*args, &block)
   #
   # See Object#try
 
@@ -129,7 +129,7 @@ class Delegator
   # :method: try!
   #
   # :call-seq:
-  #   try!(a*, &b)
+  #   try!(*args, &block)
   #
   # See Object#try!
 end
@@ -145,14 +145,14 @@ class NilClass
   #
   # With +try+
   #   @person.try(:children).try(:first).try(:name)
-  def try(_method_name = nil, *)
+  def try(*)
     nil
   end
 
   # Calling +try!+ on +nil+ always returns +nil+.
   #
   #   nil.try!(:name) # => nil
-  def try!(_method_name = nil, *)
+  def try!(*)
     nil
   end
 end

data/lib/active_support/core_ext/object/with_options.rb

@@ -64,7 +64,7 @@ class Object
   #
   # Hence the inherited default for +if+ key is ignored.
   #
-  # NOTE: You cannot call class methods implicitly inside of with_options.
+  # NOTE: You cannot call class methods implicitly inside of +with_options+.
   # You can access these methods using the class name instead:
   #
   #   class Phone < ActiveRecord::Base
@@ -75,8 +75,27 @@ class Object
   #     end
   #   end
   #
+  # When the block argument is omitted, the decorated Object instance is returned:
+  #
+  #   module MyStyledHelpers
+  #     def styled
+  #       with_options style: "color: red;"
+  #     end
+  #   end
+  #
+  #   styled.link_to "I'm red", "/"
+  #   # => <a href="/" style="color: red;">I'm red</a>
+  #
+  #   styled.button_tag "I'm red too!"
+  #   # => <button style="color: red;">I'm red too!</button>
+  #
   def with_options(options, &block)
     option_merger = ActiveSupport::OptionMerger.new(self, options)
-    block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)
+
+    if block
+      block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)
+    else
+      option_merger
+    end
   end
 end

data/lib/active_support/core_ext/pathname/existence.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Pathname
+  # Returns the receiver if the named file exists otherwise returns +nil+.
+  # <tt>pathname.existence</tt> is equivalent to
+  #
+  #    pathname.exist? ? pathname : nil
+  #
+  # For example, something like
+  #
+  #   content = pathname.read if pathname.exist?
+  #
+  # becomes
+  #
+  #   content = pathname.existence&.read
+  #
+  # @return [Pathname]
+  def existence
+    self if exist?
+  end
+end

data/lib/active_support/core_ext/pathname.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/pathname/existence"

data/lib/active_support/core_ext/range/compare_range.rb

@@ -51,31 +51,6 @@ module ActiveSupport
         super
       end
     end
-
-    # Extends the default Range#cover? to support range comparisons.
-    #  (1..5).cover?(1..5)  # => true
-    #  (1..5).cover?(2..3)  # => true
-    #  (1..5).cover?(1...6) # => true
-    #  (1..5).cover?(2..6)  # => false
-    #
-    # The native Range#cover? behavior is untouched.
-    #  ('a'..'f').cover?('c') # => true
-    #  (5..9).cover?(11) # => false
-    #
-    # The given range must be fully bounded, with both start and end.
-    def cover?(value)
-      if value.is_a?(::Range)
-        is_backwards_op = value.exclude_end? ? :>= : :>
-        return false if value.begin && value.end && value.begin.public_send(is_backwards_op, value.end)
-        # 1...10 covers 1..9 but it does not cover 1..10.
-        # 1..10 covers 1...11 but it does not cover 1...12.
-        operator = exclude_end? && !value.exclude_end? ? :< : :<=
-        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
-        super(value.first) && (self.end.nil? || value_max.public_send(operator, last))
-      else
-        super
-      end
-    end
   end
 end
 

data/lib/active_support/core_ext/range/conversions.rb

@@ -7,34 +7,34 @@ module ActiveSupport
         case start
         when String then "BETWEEN '#{start}' AND '#{stop}'"
         else
-          "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'"
+          "BETWEEN '#{start.to_fs(:db)}' AND '#{stop.to_fs(:db)}'"
         end
       end
     }
 
     # Convert range to a formatted string. See RANGE_FORMATS for predefined formats.
     #
+    # This method is aliased to <tt>to_formatted_s</tt>.
+    #
     #   range = (1..100)           # => 1..100
     #
     #   range.to_s                 # => "1..100"
-    #   range.to_s(:db)            # => "BETWEEN '1' AND '100'"
+    #   range.to_fs(:db)            # => "BETWEEN '1' AND '100'"
     #
     # == Adding your own range formats to to_s
     # You can add your own formats to the Range::RANGE_FORMATS hash.
     # Use the format name as the hash key and a Proc instance.
     #
     #   # config/initializers/range_formats.rb
-    #   Range::RANGE_FORMATS[:short] = ->(start, stop) { "Between #{start.to_s(:db)} and #{stop.to_s(:db)}" }
-    def to_s(format = :default)
+    #   Range::RANGE_FORMATS[:short] = ->(start, stop) { "Between #{start.to_fs(:db)} and #{stop.to_fs(:db)}" }
+    def to_fs(format = :default)
       if formatter = RANGE_FORMATS[format]
         formatter.call(first, last)
       else
-        super()
+        to_s
       end
     end
-
-    alias_method :to_default_s, :to_s
-    alias_method :to_formatted_s, :to_s
+    alias_method :to_formatted_s, :to_fs
   end
 end
 

data/lib/active_support/core_ext/range/deprecated_conversions.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module DeprecatedRangeWithFormat # :nodoc:
+    NOT_SET = Object.new # :nodoc:
+    def to_s(format = NOT_SET)
+      if formatter = RangeWithFormat::RANGE_FORMATS[format]
+        ActiveSupport::Deprecation.warn(
+          "Range#to_s(#{format.inspect}) is deprecated. Please use Range#to_fs(#{format.inspect}) instead."
+        )
+        formatter.call(first, last)
+      elsif format == NOT_SET
+        super()
+      else
+        ActiveSupport::Deprecation.warn(
+          "Range#to_s(#{format.inspect}) is deprecated. Please use Range#to_fs(#{format.inspect}) instead."
+        )
+        super()
+      end
+    end
+    alias_method :to_default_s, :to_s
+    deprecate :to_default_s
+  end
+end
+
+Range.prepend(ActiveSupport::DeprecatedRangeWithFormat)

data/lib/active_support/core_ext/range/each.rb

@@ -3,7 +3,7 @@
 require "active_support/time_with_zone"
 
 module ActiveSupport
-  module EachTimeWithZone #:nodoc:
+  module EachTimeWithZone # :nodoc:
     def each(&block)
       ensure_iteration_allowed
       super

data/lib/active_support/core_ext/range/include_time_with_zone.rb

@@ -1,28 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/time_with_zone"
-require "active_support/deprecation"
-
-module ActiveSupport
-  module IncludeTimeWithZone #:nodoc:
-    # Extends the default Range#include? to support ActiveSupport::TimeWithZone.
-    #
-    #   (1.hour.ago..1.hour.from_now).include?(Time.current) # => true
-    #
-    def include?(value)
-      if self.begin.is_a?(TimeWithZone) || self.end.is_a?(TimeWithZone)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          Using `Range#include?` to check the inclusion of a value in
-          a date time range is deprecated.
-          It is recommended to use `Range#cover?` instead of `Range#include?` to
-          check the inclusion of a value in a date time range.
-        MSG
-        cover?(value)
-      else
-        super
-      end
-    end
-  end
-end
-
-Range.prepend(ActiveSupport::IncludeTimeWithZone)
+ActiveSupport::Deprecation.warn(<<-MSG.squish)
+  `active_support/core_ext/range/include_time_with_zone` is deprecated and will be removed in Rails 7.1.
+MSG

data/lib/active_support/core_ext/range/overlaps.rb

@@ -5,6 +5,6 @@ class Range
   #  (1..5).overlaps?(4..6) # => true
   #  (1..5).overlaps?(7..9) # => false
   def overlaps?(other)
-    cover?(other.first) || other.cover?(first)
+    other.begin == self.begin || cover?(other.begin) || other.cover?(self.begin)
   end
 end

data/lib/active_support/core_ext/range.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/range/conversions"
+require "active_support/core_ext/range/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]
 require "active_support/core_ext/range/compare_range"
-require "active_support/core_ext/range/include_time_with_zone"
 require "active_support/core_ext/range/overlaps"
 require "active_support/core_ext/range/each"

data/lib/active_support/core_ext/securerandom.rb

@@ -12,7 +12,7 @@ module SecureRandom
   #
   # If _n_ is not specified or is +nil+, 16 is assumed. It may be larger in the future.
   #
-  # The result may contain alphanumeric characters except 0, O, I and l.
+  # The result may contain alphanumeric characters except 0, O, I, and l.
   #
   #   p SecureRandom.base58 # => "4kUgL2pdQMSCQtjE"
   #   p SecureRandom.base58(24) # => "77TMHrHJFvFDwodq8w7Ev2m7"

data/lib/active_support/core_ext/string/conversions.rb

@@ -5,10 +5,10 @@ require "active_support/core_ext/time/calculations"
 
 class String
   # Converts a string to a Time value.
-  # The +form+ can be either :utc or :local (default :local).
+  # The +form+ can be either +:utc+ or +:local+ (default +:local+).
   #
   # The time is parsed using Time.parse method.
-  # If +form+ is :local, then the time is in the system timezone.
+  # If +form+ is +:local+, then the time is in the system timezone.
   # If the date part is missing then the current date is used and if
   # the time part is missing then it is assumed to be 00:00:00.
   #

data/lib/active_support/core_ext/string/filters.rb

@@ -106,7 +106,7 @@ class String
       self.class.new.tap do |cut|
         cut_at = truncate_at - omission.bytesize
 
-        scan(/\X/) do |grapheme|
+        each_grapheme_cluster do |grapheme|
           if cut.bytesize + grapheme.bytesize <= cut_at
             cut << grapheme
           else

data/lib/active_support/core_ext/string/inflections.rb

@@ -97,8 +97,6 @@ class String
   #   'active_record/errors'.camelize         # => "ActiveRecord::Errors"
   #   'active_record/errors'.camelize(:lower) # => "activeRecord::Errors"
   #
-  # +camelize+ is also aliased as +camelcase+.
-  #
   # See ActiveSupport::Inflector.camelize.
   def camelize(first_letter = :upper)
     case first_letter
@@ -124,8 +122,6 @@ class String
   #   'x-men: the last stand'.titleize                        # => "X Men: The Last Stand"
   #   'string_ending_with_id'.titleize(keep_id_suffix: true)  # => "String Ending With Id"
   #
-  # +titleize+ is also aliased as +titlecase+.
-  #
   # See ActiveSupport::Inflector.titleize.
   def titleize(keep_id_suffix: false)
     ActiveSupport::Inflector.titleize(self, keep_id_suffix: keep_id_suffix)
@@ -260,7 +256,7 @@ class String
   #   'author_id'.humanize                          # => "Author"
   #   'author_id'.humanize(capitalize: false)       # => "author"
   #   '_id'.humanize                                # => "Id"
-  #   'author_id'.humanize(keep_id_suffix: true)    # => "Author Id"
+  #   'author_id'.humanize(keep_id_suffix: true)    # => "Author id"
   #
   # See ActiveSupport::Inflector.humanize.
   def humanize(capitalize: true, keep_id_suffix: false)

data/lib/active_support/core_ext/string/inquiry.rb

@@ -4,7 +4,7 @@ require "active_support/string_inquirer"
 require "active_support/environment_inquirer"
 
 class String
-  # Wraps the current string in the <tt>ActiveSupport::StringInquirer</tt> class,
+  # Wraps the current string in the ActiveSupport::StringInquirer class,
   # which gives you a prettier way to test for equality.
   #
   #   env = 'production'.inquiry

data/lib/active_support/core_ext/string/output_safety.rb

@@ -105,7 +105,7 @@ class ERB
     # WARNING: this helper only works with valid JSON. Using this on non-JSON values
     # will open up serious XSS vulnerabilities. For example, if you replace the
     # +current_user.to_json+ in the example above with user input instead, the browser
-    # will happily eval() that string as JavaScript.
+    # will happily <tt>eval()</tt> that string as JavaScript.
     #
     # The escaping performed in this method is identical to those performed in the
     # Active Support JSON encoder when +ActiveSupport.escape_html_entities_in_json+ is
@@ -158,7 +158,7 @@ class Numeric
   end
 end
 
-module ActiveSupport #:nodoc:
+module ActiveSupport # :nodoc:
   class SafeBuffer < String
     UNSAFE_STRING_METHODS = %w(
       capitalize chomp chop delete delete_prefix delete_suffix
@@ -171,7 +171,7 @@ module ActiveSupport #:nodoc:
     alias_method :original_concat, :concat
     private :original_concat
 
-    # Raised when <tt>ActiveSupport::SafeBuffer#safe_concat</tt> is called on unsafe buffers.
+    # Raised when ActiveSupport::SafeBuffer#safe_concat is called on unsafe buffers.
     class SafeConcatError < StandardError
       def initialize
         super "Could not concatenate to the buffer because it is not html safe."
@@ -212,27 +212,34 @@ module ActiveSupport #:nodoc:
     end
 
     def concat(value)
-      super(html_escape_interpolated_argument(value))
+      unless value.nil?
+        super(implicit_html_escape_interpolated_argument(value))
+      end
+      self
     end
     alias << concat
 
+    def bytesplice(*args, value)
+      super(*args, implicit_html_escape_interpolated_argument(value))
+    end
+
     def insert(index, value)
-      super(index, html_escape_interpolated_argument(value))
+      super(index, implicit_html_escape_interpolated_argument(value))
     end
 
     def prepend(value)
-      super(html_escape_interpolated_argument(value))
+      super(implicit_html_escape_interpolated_argument(value))
     end
 
     def replace(value)
-      super(html_escape_interpolated_argument(value))
+      super(implicit_html_escape_interpolated_argument(value))
     end
 
     def []=(*args)
       if args.length == 3
-        super(args[0], args[1], html_escape_interpolated_argument(args[2]))
+        super(args[0], args[1], implicit_html_escape_interpolated_argument(args[2]))
       else
-        super(args[0], html_escape_interpolated_argument(args[1]))
+        super(args[0], implicit_html_escape_interpolated_argument(args[1]))
       end
     end
 
@@ -250,9 +257,9 @@ module ActiveSupport #:nodoc:
     def %(args)
       case args
       when Hash
-        escaped_args = args.transform_values { |arg| html_escape_interpolated_argument(arg) }
+        escaped_args = args.transform_values { |arg| explicit_html_escape_interpolated_argument(arg) }
       else
-        escaped_args = Array(args).map { |arg| html_escape_interpolated_argument(arg) }
+        escaped_args = Array(args).map { |arg| explicit_html_escape_interpolated_argument(arg) }
       end
 
       self.class.new(super(escaped_args))
@@ -290,39 +297,60 @@ module ActiveSupport #:nodoc:
     end
 
     UNSAFE_STRING_METHODS_WITH_BACKREF.each do |unsafe_method|
-      if unsafe_method.respond_to?(unsafe_method)
-        class_eval <<-EOT, __FILE__, __LINE__ + 1
-          def #{unsafe_method}(*args, &block)             # def gsub(*args, &block)
-            if block                                      #   if block
-              to_str.#{unsafe_method}(*args) { |*params|  #     to_str.gsub(*args) { |*params|
-                set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
-                block.call(*params)                       #       block.call(*params)
-              }                                           #     }
-            else                                          #   else
-              to_str.#{unsafe_method}(*args)              #     to_str.gsub(*args)
-            end                                           #   end
-          end                                             # end
-
-          def #{unsafe_method}!(*args, &block)            # def gsub!(*args, &block)
-            @html_safe = false                            #   @html_safe = false
-            if block                                      #   if block
-              super(*args) { |*params|                    #     super(*args) { |*params|
-                set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
-                block.call(*params)                       #       block.call(*params)
-              }                                           #     }
-            else                                          #   else
-              super                                       #     super
-            end                                           #   end
-          end                                             # end
-        EOT
-      end
+      class_eval <<-EOT, __FILE__, __LINE__ + 1
+        def #{unsafe_method}(*args, &block)             # def gsub(*args, &block)
+          if block                                      #   if block
+            to_str.#{unsafe_method}(*args) { |*params|  #     to_str.gsub(*args) { |*params|
+              set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
+              block.call(*params)                       #       block.call(*params)
+            }                                           #     }
+          else                                          #   else
+            to_str.#{unsafe_method}(*args)              #     to_str.gsub(*args)
+          end                                           #   end
+        end                                             # end
+
+        def #{unsafe_method}!(*args, &block)            # def gsub!(*args, &block)
+          @html_safe = false                            #   @html_safe = false
+          if block                                      #   if block
+            super(*args) { |*params|                    #     super(*args) { |*params|
+              set_block_back_references(block, $~)      #       set_block_back_references(block, $~)
+              block.call(*params)                       #       block.call(*params)
+            }                                           #     }
+          else                                          #   else
+            super                                       #     super
+          end                                           #   end
+        end                                             # end
+      EOT
     end
 
     private
-      def html_escape_interpolated_argument(arg)
+      def explicit_html_escape_interpolated_argument(arg)
         (!html_safe? || arg.html_safe?) ? arg : CGI.escapeHTML(arg.to_s)
       end
 
+      def implicit_html_escape_interpolated_argument(arg)
+        if !html_safe? || arg.html_safe?
+          arg
+        else
+          arg_string = begin
+            arg.to_str
+          rescue NoMethodError => error
+            if error.name == :to_str
+              str = arg.to_s
+              ActiveSupport::Deprecation.warn <<~MSG.squish
+                Implicit conversion of #{arg.class} into String by ActiveSupport::SafeBuffer
+                is deprecated and will be removed in Rails 7.1.
+                You must explicitly cast it to a String.
+              MSG
+              str
+            else
+              raise
+            end
+          end
+          CGI.escapeHTML(arg_string)
+        end
+      end
+
       def set_block_back_references(block, match_data)
         block.binding.eval("proc { |m| $~ = m }").call(match_data)
       rescue ArgumentError

data/lib/active_support/core_ext/symbol/starts_ends_with.rb

@@ -1,14 +1,6 @@
 # frozen_string_literal: true
 
 class Symbol
-  def start_with?(*prefixes)
-    to_s.start_with?(*prefixes)
-  end unless method_defined?(:start_with?)
-
-  def end_with?(*suffixes)
-    to_s.end_with?(*suffixes)
-  end unless method_defined?(:end_with?)
-
   alias :starts_with? :start_with?
   alias :ends_with? :end_with?
 end

data/lib/active_support/core_ext/time/calculations.rb

@@ -42,8 +42,8 @@ class Time
 
     # Layers additional behavior on Time.at so that ActiveSupport::TimeWithZone and DateTime
     # instances can be used when called with a single argument
-    def at_with_coercion(*args)
-      return at_without_coercion(*args) if args.size != 1
+    def at_with_coercion(*args, **kwargs)
+      return at_without_coercion(*args, **kwargs) if args.size != 1 || !kwargs.empty?
 
       # Time.at can be called with a time or numerical value
       time_or_number = args.first
@@ -56,7 +56,6 @@ class Time
         at_without_coercion(time_or_number)
       end
     end
-    ruby2_keywords(:at_with_coercion) if respond_to?(:ruby2_keywords, true)
     alias_method :at_without_coercion, :at
     alias_method :at, :at_with_coercion
 
@@ -127,8 +126,8 @@ class Time
   # Returns a new Time where one or more of the elements have been changed according
   # to the +options+ parameter. The time options (<tt>:hour</tt>, <tt>:min</tt>,
   # <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>) reset cascadingly, so if only
-  # the hour is passed, then minute, sec, usec and nsec is set to 0. If the hour
-  # and minute is passed, then sec, usec and nsec is set to 0. The +options+ parameter
+  # the hour is passed, then minute, sec, usec, and nsec is set to 0. If the hour
+  # and minute is passed, then sec, usec, and nsec is set to 0. The +options+ parameter
   # takes a hash with any of these keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>,
   # <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>,
   # <tt>:offset</tt>. Pass either <tt>:usec</tt> or <tt>:nsec</tt>, not both.
@@ -180,6 +179,10 @@ class Time
   #   Time.new(2015, 8, 1, 14, 35, 0).advance(hours: 1)   # => 2015-08-01 15:35:00 -0700
   #   Time.new(2015, 8, 1, 14, 35, 0).advance(days: 1)    # => 2015-08-02 14:35:00 -0700
   #   Time.new(2015, 8, 1, 14, 35, 0).advance(weeks: 1)   # => 2015-08-08 14:35:00 -0700
+  #
+  # Just like Date#advance, increments are applied in order of time units from
+  # largest to smallest. This order can affect the result around the end of a
+  # month.
   def advance(options)
     unless options[:weeks].nil?
       options[:weeks], partial_weeks = options[:weeks].divmod(1)
@@ -278,7 +281,7 @@ class Time
   end
   alias :at_end_of_minute :end_of_minute
 
-  def plus_with_duration(other) #:nodoc:
+  def plus_with_duration(other) # :nodoc:
     if ActiveSupport::Duration === other
       other.since(self)
     else
@@ -288,7 +291,7 @@ class Time
   alias_method :plus_without_duration, :+
   alias_method :+, :plus_with_duration
 
-  def minus_with_duration(other) #:nodoc:
+  def minus_with_duration(other) # :nodoc:
     if ActiveSupport::Duration === other
       other.until(self)
     else
@@ -306,7 +309,7 @@ class Time
     other.is_a?(DateTime) ? to_f - other.to_f : minus_without_coercion(other)
   end
   alias_method :minus_without_coercion, :-
-  alias_method :-, :minus_with_coercion
+  alias_method :-, :minus_with_coercion # rubocop:disable Lint/DuplicateMethods
 
   # Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances
   # can be chronologically compared with a Time