activesupport 4.2.11.1 → 5.2.8.1

data/lib/active_support/core_ext/module/deprecation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Module
   #   deprecate :foo
   #   deprecate bar: 'message'
@@ -13,8 +15,8 @@ class Module
   #
   #   class MyLib::Deprecator
   #     def deprecation_warning(deprecated_method_name, message, caller_backtrace = nil)
-  #        message = "#{deprecated_method_name} is deprecated and will be removed from MyLibrary | #{message}"
-  #        Kernel.warn message
+  #       message = "#{deprecated_method_name} is deprecated and will be removed from MyLibrary | #{message}"
+  #       Kernel.warn message
   #     end
   #   end
   def deprecate(*method_names)

data/lib/active_support/core_ext/module/introspection.rb

@@ -1,14 +1,18 @@
-require 'active_support/inflector'
+# frozen_string_literal: true
+
+require "active_support/inflector"
 
 class Module
   # Returns the name of the module containing this one.
   #
   #   M::N.parent_name # => "M"
   def parent_name
-    if defined? @parent_name
+    if defined?(@parent_name)
       @parent_name
     else
-      @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
+      parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
+      @parent_name = parent_name unless frozen?
+      parent_name
     end
   end
 
@@ -46,17 +50,13 @@ class Module
   def parents
     parents = []
     if parent_name
-      parts = parent_name.split('::')
+      parts = parent_name.split("::")
       until parts.empty?
-        parents << ActiveSupport::Inflector.constantize(parts * '::')
+        parents << ActiveSupport::Inflector.constantize(parts * "::")
         parts.pop
       end
     end
     parents << Object unless parents.include? Object
     parents
   end
-
-  def local_constants #:nodoc:
-    constants(false)
-  end
 end

data/lib/active_support/core_ext/module/reachable.rb

@@ -1,8 +1,11 @@
-require 'active_support/core_ext/module/anonymous'
-require 'active_support/core_ext/string/inflections'
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/anonymous"
+require "active_support/core_ext/string/inflections"
 
 class Module
   def reachable? #:nodoc:
     !anonymous? && name.safe_constantize.equal?(self)
   end
+  deprecate :reachable?
 end

data/lib/active_support/core_ext/module/redefine_method.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class Module
+  if RUBY_VERSION >= "2.3"
+    # Marks the named method as intended to be redefined, if it exists.
+    # Suppresses the Ruby method redefinition warning. Prefer
+    # #redefine_method where possible.
+    def silence_redefinition_of_method(method)
+      if method_defined?(method) || private_method_defined?(method)
+        # This suppresses the "method redefined" warning; the self-alias
+        # looks odd, but means we don't need to generate a unique name
+        alias_method method, method
+      end
+    end
+  else
+    def silence_redefinition_of_method(method)
+      if method_defined?(method) || private_method_defined?(method)
+        alias_method :__rails_redefine, method
+        remove_method :__rails_redefine
+      end
+    end
+  end
+
+  # Replaces the existing method definition, if there is one, with the passed
+  # block as its body.
+  def redefine_method(method, &block)
+    visibility = method_visibility(method)
+    silence_redefinition_of_method(method)
+    define_method(method, &block)
+    send(visibility, method)
+  end
+
+  # Replaces the existing singleton method definition, if there is one, with
+  # the passed block as its body.
+  def redefine_singleton_method(method, &block)
+    singleton_class.redefine_method(method, &block)
+  end
+
+  def method_visibility(method) # :nodoc:
+    case
+    when private_method_defined?(method)
+      :private
+    when protected_method_defined?(method)
+      :protected
+    else
+      :public
+    end
+  end
+end

data/lib/active_support/core_ext/module/remove_method.rb

@@ -1,12 +1,17 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/redefine_method"
+
 class Module
+  # Removes the named method, if it exists.
   def remove_possible_method(method)
     if method_defined?(method) || private_method_defined?(method)
       undef_method(method)
     end
   end
 
-  def redefine_method(method, &block)
-    remove_possible_method(method)
-    define_method(method, &block)
+  # Removes the named singleton method, if it exists.
+  def remove_possible_singleton_method(method)
+    singleton_class.remove_possible_method(method)
   end
 end

data/lib/active_support/core_ext/module.rb

@@ -1,11 +1,14 @@
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/module/introspection'
-require 'active_support/core_ext/module/anonymous'
-require 'active_support/core_ext/module/reachable'
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/module/attr_internal'
-require 'active_support/core_ext/module/concerning'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/module/deprecation'
-require 'active_support/core_ext/module/remove_method'
-require 'active_support/core_ext/module/qualified_const'
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/aliasing"
+require "active_support/core_ext/module/introspection"
+require "active_support/core_ext/module/anonymous"
+require "active_support/core_ext/module/reachable"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/module/attribute_accessors_per_thread"
+require "active_support/core_ext/module/attr_internal"
+require "active_support/core_ext/module/concerning"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/module/deprecation"
+require "active_support/core_ext/module/redefine_method"
+require "active_support/core_ext/module/remove_method"

data/lib/active_support/core_ext/name_error.rb

@@ -1,16 +1,36 @@
+# frozen_string_literal: true
+
 class NameError
   # Extract the name of the missing constant from the exception message.
+  #
+  #   begin
+  #     HelloWorld
+  #   rescue NameError => e
+  #     e.missing_name
+  #   end
+  #   # => "HelloWorld"
   def missing_name
+    # Since ruby v2.3.0 `did_you_mean` gem is loaded by default.
+    # It extends NameError#message with spell corrections which are SLOW.
+    # We should use original_message message instead.
+    message = respond_to?(:original_message) ? original_message : self.message
+
     if /undefined local variable or method/ !~ message
       $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
     end
   end
 
   # Was this exception raised because the given name was missing?
+  #
+  #   begin
+  #     HelloWorld
+  #   rescue NameError => e
+  #     e.missing_name?("HelloWorld")
+  #   end
+  #   # => true
   def missing_name?(name)
     if name.is_a? Symbol
-      last_name = (missing_name || '').split('::').last
-      last_name == name.to_s
+      self.name == name
     else
       missing_name == name.to_s
     end

data/lib/active_support/core_ext/numeric/bytes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Numeric
   KILOBYTE = 1024
   MEGABYTE = KILOBYTE * 1024
@@ -7,36 +9,56 @@ class Numeric
   EXABYTE  = PETABYTE * 1024
 
   # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
+  #
+  #   2.bytes # => 2
   def bytes
     self
   end
   alias :byte :bytes
 
+  # Returns the number of bytes equivalent to the kilobytes provided.
+  #
+  #   2.kilobytes # => 2048
   def kilobytes
     self * KILOBYTE
   end
   alias :kilobyte :kilobytes
 
+  # Returns the number of bytes equivalent to the megabytes provided.
+  #
+  #   2.megabytes # => 2_097_152
   def megabytes
     self * MEGABYTE
   end
   alias :megabyte :megabytes
 
+  # Returns the number of bytes equivalent to the gigabytes provided.
+  #
+  #   2.gigabytes # => 2_147_483_648
   def gigabytes
     self * GIGABYTE
   end
   alias :gigabyte :gigabytes
 
+  # Returns the number of bytes equivalent to the terabytes provided.
+  #
+  #   2.terabytes # => 2_199_023_255_552
   def terabytes
     self * TERABYTE
   end
   alias :terabyte :terabytes
 
+  # Returns the number of bytes equivalent to the petabytes provided.
+  #
+  #   2.petabytes # => 2_251_799_813_685_248
   def petabytes
     self * PETABYTE
   end
   alias :petabyte :petabytes
 
+  # Returns the number of bytes equivalent to the exabytes provided.
+  #
+  #   2.exabytes # => 2_305_843_009_213_693_952
   def exabytes
     self * EXABYTE
   end

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

@@ -1,8 +1,10 @@
-require 'active_support/core_ext/big_decimal/conversions'
-require 'active_support/number_helper'
+# frozen_string_literal: true
 
-class Numeric
+require "active_support/core_ext/big_decimal/conversions"
+require "active_support/number_helper"
+require "active_support/core_ext/module/deprecation"
 
+module ActiveSupport::NumericWithFormat
   # Provides options for converting numbers into formatted strings.
   # Options are provided for phone numbers, currency, percentage,
   # precision, positional notation, file size and pretty printing.
@@ -14,70 +16,72 @@ class Numeric
   # ==== Examples
   #
   #  Phone Numbers:
-  #  5551234.to_s(:phone)                                     # => 555-1234
-  #  1235551234.to_s(:phone)                                  # => 123-555-1234
-  #  1235551234.to_s(:phone, area_code: true)                 # => (123) 555-1234
-  #  1235551234.to_s(:phone, delimiter: ' ')                  # => 123 555 1234
-  #  1235551234.to_s(:phone, area_code: true, extension: 555) # => (123) 555-1234 x 555
-  #  1235551234.to_s(:phone, country_code: 1)                 # => +1-123-555-1234
+  #  5551234.to_s(:phone)                                     # => "555-1234"
+  #  1235551234.to_s(:phone)                                  # => "123-555-1234"
+  #  1235551234.to_s(:phone, area_code: true)                 # => "(123) 555-1234"
+  #  1235551234.to_s(:phone, delimiter: ' ')                  # => "123 555 1234"
+  #  1235551234.to_s(:phone, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
+  #  1235551234.to_s(:phone, country_code: 1)                 # => "+1-123-555-1234"
   #  1235551234.to_s(:phone, country_code: 1, extension: 1343, delimiter: '.')
-  #  # => +1.123.555.1234 x 1343
+  #  # => "+1.123.555.1234 x 1343"
   #
   #  Currency:
-  #  1234567890.50.to_s(:currency)                 # => $1,234,567,890.50
-  #  1234567890.506.to_s(:currency)                # => $1,234,567,890.51
-  #  1234567890.506.to_s(:currency, precision: 3)  # => $1,234,567,890.506
-  #  1234567890.506.to_s(:currency, locale: :fr)   # => 1 234 567 890,51 €
+  #  1234567890.50.to_s(:currency)                 # => "$1,234,567,890.50"
+  #  1234567890.506.to_s(:currency)                # => "$1,234,567,890.51"
+  #  1234567890.506.to_s(:currency, precision: 3)  # => "$1,234,567,890.506"
+  #  1234567890.506.to_s(:currency, locale: :fr)   # => "1 234 567 890,51 €"
   #  -1234567890.50.to_s(:currency, negative_format: '(%u%n)')
-  #  # => ($1,234,567,890.50)
+  #  # => "($1,234,567,890.50)"
   #  1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '')
-  #  # => £1234567890,50
+  #  # => "£1234567890,50"
   #  1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '', format: '%n %u')
-  #  # => 1234567890,50 £
+  #  # => "1234567890,50 £"
   #
   #  Percentage:
-  #  100.to_s(:percentage)                                  # => 100.000%
-  #  100.to_s(:percentage, precision: 0)                    # => 100%
-  #  1000.to_s(:percentage, delimiter: '.', separator: ',') # => 1.000,000%
-  #  302.24398923423.to_s(:percentage, precision: 5)        # => 302.24399%
-  #  1000.to_s(:percentage, locale: :fr)                    # => 1 000,000%
-  #  100.to_s(:percentage, format: '%n  %')                 # => 100.000  %
+  #  100.to_s(:percentage)                                  # => "100.000%"
+  #  100.to_s(:percentage, precision: 0)                    # => "100%"
+  #  1000.to_s(:percentage, delimiter: '.', separator: ',') # => "1.000,000%"
+  #  302.24398923423.to_s(:percentage, precision: 5)        # => "302.24399%"
+  #  1000.to_s(:percentage, locale: :fr)                    # => "1 000,000%"
+  #  100.to_s(:percentage, format: '%n  %')                 # => "100.000  %"
   #
   #  Delimited:
-  #  12345678.to_s(:delimited)                     # => 12,345,678
-  #  12345678.05.to_s(:delimited)                  # => 12,345,678.05
-  #  12345678.to_s(:delimited, delimiter: '.')     # => 12.345.678
-  #  12345678.to_s(:delimited, delimiter: ',')     # => 12,345,678
-  #  12345678.05.to_s(:delimited, separator: ' ')  # => 12,345,678 05
-  #  12345678.05.to_s(:delimited, locale: :fr)     # => 12 345 678,05
+  #  12345678.to_s(:delimited)                     # => "12,345,678"
+  #  12345678.05.to_s(:delimited)                  # => "12,345,678.05"
+  #  12345678.to_s(:delimited, delimiter: '.')     # => "12.345.678"
+  #  12345678.to_s(:delimited, delimiter: ',')     # => "12,345,678"
+  #  12345678.05.to_s(:delimited, separator: ' ')  # => "12,345,678 05"
+  #  12345678.05.to_s(:delimited, locale: :fr)     # => "12 345 678,05"
   #  98765432.98.to_s(:delimited, delimiter: ' ', separator: ',')
-  #  # => 98 765 432,98
+  #  # => "98 765 432,98"
   #
   #  Rounded:
-  #  111.2345.to_s(:rounded)                                      # => 111.235
-  #  111.2345.to_s(:rounded, precision: 2)                        # => 111.23
-  #  13.to_s(:rounded, precision: 5)                              # => 13.00000
-  #  389.32314.to_s(:rounded, precision: 0)                       # => 389
-  #  111.2345.to_s(:rounded, significant: true)                   # => 111
-  #  111.2345.to_s(:rounded, precision: 1, significant: true)     # => 100
-  #  13.to_s(:rounded, precision: 5, significant: true)           # => 13.000
-  #  111.234.to_s(:rounded, locale: :fr)                          # => 111,234
+  #  111.2345.to_s(:rounded)                                      # => "111.235"
+  #  111.2345.to_s(:rounded, precision: 2)                        # => "111.23"
+  #  13.to_s(:rounded, precision: 5)                              # => "13.00000"
+  #  389.32314.to_s(:rounded, precision: 0)                       # => "389"
+  #  111.2345.to_s(:rounded, significant: true)                   # => "111"
+  #  111.2345.to_s(:rounded, precision: 1, significant: true)     # => "100"
+  #  13.to_s(:rounded, precision: 5, significant: true)           # => "13.000"
+  #  111.234.to_s(:rounded, locale: :fr)                          # => "111,234"
   #  13.to_s(:rounded, precision: 5, significant: true, strip_insignificant_zeros: true)
-  #  # => 13
-  #  389.32314.to_s(:rounded, precision: 4, significant: true)    # => 389.3
+  #  # => "13"
+  #  389.32314.to_s(:rounded, precision: 4, significant: true)    # => "389.3"
   #  1111.2345.to_s(:rounded, precision: 2, separator: ',', delimiter: '.')
-  #  # => 1.111,23
+  #  # => "1.111,23"
   #
   #  Human-friendly size in Bytes:
-  #  123.to_s(:human_size)                                   # => 123 Bytes
-  #  1234.to_s(:human_size)                                  # => 1.21 KB
-  #  12345.to_s(:human_size)                                 # => 12.1 KB
-  #  1234567.to_s(:human_size)                               # => 1.18 MB
-  #  1234567890.to_s(:human_size)                            # => 1.15 GB
-  #  1234567890123.to_s(:human_size)                         # => 1.12 TB
-  #  1234567.to_s(:human_size, precision: 2)                 # => 1.2 MB
-  #  483989.to_s(:human_size, precision: 2)                  # => 470 KB
-  #  1234567.to_s(:human_size, precision: 2, separator: ',') # => 1,2 MB
+  #  123.to_s(:human_size)                                   # => "123 Bytes"
+  #  1234.to_s(:human_size)                                  # => "1.21 KB"
+  #  12345.to_s(:human_size)                                 # => "12.1 KB"
+  #  1234567.to_s(:human_size)                               # => "1.18 MB"
+  #  1234567890.to_s(:human_size)                            # => "1.15 GB"
+  #  1234567890123.to_s(:human_size)                         # => "1.12 TB"
+  #  1234567890123456.to_s(:human_size)                      # => "1.1 PB"
+  #  1234567890123456789.to_s(:human_size)                   # => "1.07 EB"
+  #  1234567.to_s(:human_size, precision: 2)                 # => "1.2 MB"
+  #  483989.to_s(:human_size, precision: 2)                  # => "470 KB"
+  #  1234567.to_s(:human_size, precision: 2, separator: ',') # => "1,2 MB"
   #  1234567890123.to_s(:human_size, precision: 5)           # => "1.1228 TB"
   #  524288000.to_s(:human_size, precision: 5)               # => "500 MB"
   #
@@ -97,47 +101,40 @@ class Numeric
   #  1234567.to_s(:human, precision: 1,
   #                   separator: ',',
   #                   significant: false)                   # => "1,2 Million"
-  def to_formatted_s(format = :default, options = {})
+  def to_s(format = nil, options = nil)
     case format
+    when nil
+      super()
+    when Integer, String
+      super(format)
     when :phone
-      return ActiveSupport::NumberHelper.number_to_phone(self, options)
+      ActiveSupport::NumberHelper.number_to_phone(self, options || {})
     when :currency
-      return ActiveSupport::NumberHelper.number_to_currency(self, options)
+      ActiveSupport::NumberHelper.number_to_currency(self, options || {})
     when :percentage
-      return ActiveSupport::NumberHelper.number_to_percentage(self, options)
+      ActiveSupport::NumberHelper.number_to_percentage(self, options || {})
     when :delimited
-      return ActiveSupport::NumberHelper.number_to_delimited(self, options)
+      ActiveSupport::NumberHelper.number_to_delimited(self, options || {})
     when :rounded
-      return ActiveSupport::NumberHelper.number_to_rounded(self, options)
+      ActiveSupport::NumberHelper.number_to_rounded(self, options || {})
     when :human
-      return ActiveSupport::NumberHelper.number_to_human(self, options)
+      ActiveSupport::NumberHelper.number_to_human(self, options || {})
     when :human_size
-      return ActiveSupport::NumberHelper.number_to_human_size(self, options)
+      ActiveSupport::NumberHelper.number_to_human_size(self, options || {})
+    when Symbol
+      super()
     else
-      self.to_default_s
+      super(format)
     end
   end
+end
 
-  klasses = [Float, BigDecimal]
-  # Ruby 2.4+ unifies Fixnum & Bignum into Integer.
-  if 0.class == Integer
-    klasses << Integer
-  else
-    klasses << Fixnum << Bignum
-  end
-
-  klasses.each do |klass|
-    klass.send(:alias_method, :to_default_s, :to_s)
-
-    klass.send(:define_method, :to_s) do |*args|
-      if args[0].is_a?(Symbol)
-        format = args[0]
-        options = args[1] || {}
-
-        self.to_formatted_s(format, options)
-      else
-        to_default_s(*args)
-      end
-    end
-  end
+# Ruby 2.4+ unifies Fixnum & Bignum into Integer.
+if 0.class == Integer
+  Integer.prepend ActiveSupport::NumericWithFormat
+else
+  Fixnum.prepend ActiveSupport::NumericWithFormat
+  Bignum.prepend ActiveSupport::NumericWithFormat
 end
+Float.prepend ActiveSupport::NumericWithFormat
+BigDecimal.prepend ActiveSupport::NumericWithFormat

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+unless 1.respond_to?(:positive?) # TODO: Remove this file when we drop support to ruby < 2.3
+  class Numeric
+    # Returns true if the number is positive.
+    #
+    #   1.positive?  # => true
+    #   0.positive?  # => false
+    #   -1.positive? # => false
+    def positive?
+      self > 0
+    end
+
+    # Returns true if the number is negative.
+    #
+    #   -1.negative? # => true
+    #   0.negative?  # => false
+    #   1.negative?  # => false
+    def negative?
+      self < 0
+    end
+  end
+
+  class Complex
+    undef :positive?
+    undef :negative?
+  end
+end

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

@@ -1,53 +1,65 @@
-require 'active_support/duration'
-require 'active_support/core_ext/time/calculations'
-require 'active_support/core_ext/time/acts_like'
+# frozen_string_literal: true
+
+require "active_support/duration"
+require "active_support/core_ext/time/calculations"
+require "active_support/core_ext/time/acts_like"
+require "active_support/core_ext/date/calculations"
+require "active_support/core_ext/date/acts_like"
 
 class Numeric
-  # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
-  #
-  # These methods use Time#advance for precise date calculations when using from_now, ago, etc.
-  # as well as adding or subtracting their results from a Time object. For example:
-  #
-  #   # equivalent to Time.current.advance(months: 1)
-  #   1.month.from_now
+  # Returns a Duration instance matching the number of seconds provided.
   #
-  #   # equivalent to Time.current.advance(years: 2)
-  #   2.years.from_now
-  #
-  #   # equivalent to Time.current.advance(months: 4, years: 5)
-  #   (4.months + 5.years).from_now
+  #   2.seconds # => 2 seconds
   def seconds
-    ActiveSupport::Duration.new(self, [[:seconds, self]])
+    ActiveSupport::Duration.seconds(self)
   end
   alias :second :seconds
 
+  # Returns a Duration instance matching the number of minutes provided.
+  #
+  #   2.minutes # => 2 minutes
   def minutes
-    ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
+    ActiveSupport::Duration.minutes(self)
   end
   alias :minute :minutes
 
+  # Returns a Duration instance matching the number of hours provided.
+  #
+  #   2.hours # => 2 hours
   def hours
-    ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
+    ActiveSupport::Duration.hours(self)
   end
   alias :hour :hours
 
+  # Returns a Duration instance matching the number of days provided.
+  #
+  #   2.days # => 2 days
   def days
-    ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
+    ActiveSupport::Duration.days(self)
   end
   alias :day :days
 
+  # Returns a Duration instance matching the number of weeks provided.
+  #
+  #   2.weeks # => 2 weeks
   def weeks
-    ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
+    ActiveSupport::Duration.weeks(self)
   end
   alias :week :weeks
 
+  # Returns a Duration instance matching the number of fortnights provided.
+  #
+  #   2.fortnights # => 4 weeks
   def fortnights
-    ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
+    ActiveSupport::Duration.weeks(self * 2)
   end
   alias :fortnight :fortnights
 
-  # Used with the standard time durations, like 1.hour.in_milliseconds --
-  # so we can feed them to JavaScript functions like getTime().
+  # Returns the number of milliseconds equivalent to the seconds provided.
+  # Used with the standard time durations.
+  #
+  #   2.in_milliseconds # => 2000
+  #   1.hour.in_milliseconds # => 3600000
   def in_milliseconds
     self * 1000
   end

data/lib/active_support/core_ext/numeric.rb

@@ -1,3 +1,6 @@
-require 'active_support/core_ext/numeric/bytes'
-require 'active_support/core_ext/numeric/time'
-require 'active_support/core_ext/numeric/conversions'
+# frozen_string_literal: true
+
+require "active_support/core_ext/numeric/bytes"
+require "active_support/core_ext/numeric/time"
+require "active_support/core_ext/numeric/inquiry"
+require "active_support/core_ext/numeric/conversions"

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Object
   # A duck-type assistant method. For example, Active Support extends Date
   # to define an <tt>acts_like_date?</tt> method, and extends Time to define
@@ -5,6 +7,15 @@ class Object
   # <tt>x.acts_like?(:date)</tt> to do duck-type-safe comparisons, since classes that
   # we want to act like Time simply need to define an <tt>acts_like_time?</tt> method.
   def acts_like?(duck)
-    respond_to? :"acts_like_#{duck}?"
+    case duck
+    when :time
+      respond_to? :acts_like_time?
+    when :date
+      respond_to? :acts_like_date?
+    when :string
+      respond_to? :acts_like_string?
+    else
+      respond_to? :"acts_like_#{duck}?"
+    end
   end
 end