activesupport 5.2.6 → 6.0.0.beta1

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

@@ -1,28 +1,5 @@
 # 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
+require "active_support/deprecation"
 
-    # 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
+ActiveSupport::Deprecation.warn "Ruby 2.5+ (required by Rails 6) provides Numeric#positive? and Numeric#negative? natively, so requiring active_support/core_ext/numeric/inquiry is no longer necessary. Requiring it will raise LoadError in Rails 6.1."

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

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/regexp"
 require "concurrent/map"
 
 class Object
   # An object is blank if it's false, empty, or a whitespace string.
-  # For example, +false+, '', '   ', +nil+, [], and {} are all blank.
+  # For example, +nil+, '', '   ', [], {}, and +false+ are all blank.
   #
   # This simplifies
   #

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

@@ -75,8 +75,11 @@ end
 
 class Symbol
   begin
-    :symbol.dup # Ruby 2.4.x.
-    "symbol_from_string".to_sym.dup # Some symbols can't `dup` in Ruby 2.4.0.
+    :symbol.dup
+
+    # Some symbols couldn't be duped in Ruby 2.4.0 only, due to a bug.
+    # This feature check catches any regression.
+    "symbol_from_string".to_sym.dup
   rescue TypeError
 
     # Symbols are not duplicable:

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

@@ -14,6 +14,7 @@ require "active_support/core_ext/time/conversions"
 require "active_support/core_ext/date_time/conversions"
 require "active_support/core_ext/date/conversions"
 
+#--
 # The JSON gem adds a few modules to Ruby core classes containing :to_json definition, overwriting
 # their default behavior. That said, we need to define the basic to_json method in all of them,
 # otherwise they will always use to_json gem implementation, which is backwards incompatible in

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

@@ -4,19 +4,27 @@ require "delegate"
 
 module ActiveSupport
   module Tryable #:nodoc:
-    def try(*a, &b)
-      try!(*a, &b) if a.empty? || respond_to?(a.first)
+    def try(method_name = nil, *args, &b)
+      if method_name.nil? && block_given?
+        if b.arity == 0
+          instance_eval(&b)
+        else
+          yield self
+        end
+      elsif respond_to?(method_name)
+        public_send(method_name, *args, &b)
+      end
     end
 
-    def try!(*a, &b)
-      if a.empty? && block_given?
+    def try!(method_name = nil, *args, &b)
+      if method_name.nil? && block_given?
         if b.arity == 0
           instance_eval(&b)
         else
           yield self
         end
       else
-        public_send(*a, &b)
+        public_send(method_name, *args, &b)
       end
     end
   end
@@ -135,14 +143,14 @@ class NilClass
   #
   # With +try+
   #   @person.try(:children).try(:first).try(:name)
-  def try(*args)
+  def try(method_name = nil, *args)
     nil
   end
 
   # Calling +try!+ on +nil+ always returns +nil+.
   #
   #   nil.try!(:name) # => nil
-  def try!(*args)
+  def try!(method_name = nil, *args)
     nil
   end
 end

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

@@ -68,7 +68,7 @@ class Object
   # You can access these methods using the class name instead:
   #
   #   class Phone < ActiveRecord::Base
-  #     enum phone_number_type: [home: 0, office: 1, mobile: 2]
+  #     enum phone_number_type: { home: 0, office: 1, mobile: 2 }
   #
   #     with_options presence: true do
   #       validates :phone_number_type, inclusion: { in: Phone.phone_number_types.keys }

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveSupport
-  module CompareWithRange #:nodoc:
+  module CompareWithRange
     # Extends the default Range#=== to support range comparisons.
     #  (1..5) === (1..5) # => true
     #  (1..5) === (2..3) # => true

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

@@ -1,39 +1,41 @@
 # frozen_string_literal: true
 
-module ActiveSupport::RangeWithFormat
-  RANGE_FORMATS = {
-    db: -> (start, stop) do
-      case start
-      when String then "BETWEEN '#{start}' AND '#{stop}'"
+module ActiveSupport
+  module RangeWithFormat
+    RANGE_FORMATS = {
+      db: -> (start, stop) do
+        case start
+        when String then "BETWEEN '#{start}' AND '#{stop}'"
+        else
+          "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'"
+        end
+      end
+    }
+
+    # Convert range to a formatted string. See RANGE_FORMATS for predefined formats.
+    #
+    #   range = (1..100)           # => 1..100
+    #
+    #   range.to_s                 # => "1..100"
+    #   range.to_s(: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)
+      if formatter = RANGE_FORMATS[format]
+        formatter.call(first, last)
       else
-        "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'"
+        super()
       end
     end
-  }
 
-  # Convert range to a formatted string. See RANGE_FORMATS for predefined formats.
-  #
-  #   range = (1..100)           # => 1..100
-  #
-  #   range.to_s                 # => "1..100"
-  #   range.to_s(: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)
-    if formatter = RANGE_FORMATS[format]
-      formatter.call(first, last)
-    else
-      super()
-    end
+    alias_method :to_default_s, :to_s
+    alias_method :to_formatted_s, :to_s
   end
-
-  alias_method :to_default_s, :to_s
-  alias_method :to_formatted_s, :to_s
 end
 
 Range.prepend(ActiveSupport::RangeWithFormat)

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

@@ -1,3 +1,9 @@
 # frozen_string_literal: true
 
+require "active_support/deprecation"
+
+ActiveSupport::Deprecation.warn "You have required `active_support/core_ext/range/include_range`. " \
+"This file will be removed in Rails 6.1. You should require `active_support/core_ext/range/compare_range` " \
+  "instead."
+
 require "active_support/core_ext/range/compare_range"

data/lib/active_support/core_ext/regexp.rb

@@ -4,8 +4,4 @@ class Regexp #:nodoc:
   def multiline?
     options & MULTILINE == MULTILINE
   end
-
-  def match?(string, pos = 0)
-    !!match(string, pos)
-  end unless //.respond_to?(:match?)
 end

data/lib/active_support/core_ext/securerandom.rb

@@ -4,17 +4,18 @@ require "securerandom"
 
 module SecureRandom
   BASE58_ALPHABET = ("0".."9").to_a + ("A".."Z").to_a + ("a".."z").to_a - ["0", "O", "I", "l"]
+  BASE36_ALPHABET = ("0".."9").to_a + ("a".."z").to_a
+
   # SecureRandom.base58 generates a random base58 string.
   #
-  # The argument _n_ specifies the length, of the random string to be generated.
+  # The argument _n_ specifies the length of the random string to be generated.
   #
   # 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"
-  #
   def self.base58(n = 16)
     SecureRandom.random_bytes(n).unpack("C*").map do |byte|
       idx = byte % 64
@@ -22,4 +23,23 @@ module SecureRandom
       BASE58_ALPHABET[idx]
     end.join
   end
+
+  # SecureRandom.base36 generates a random base36 string in lowercase.
+  #
+  # The argument _n_ specifies the length of the random string to be generated.
+  #
+  # If _n_ is not specified or is +nil+, 16 is assumed. It may be larger in the future.
+  # This method can be used over +base58+ if a deterministic case key is necessary.
+  #
+  # The result will contain alphanumeric characters in lowercase.
+  #
+  #   p SecureRandom.base36 # => "4kugl2pdqmscqtje"
+  #   p SecureRandom.base36(24) # => "77tmhrhjfvfdwodq8w7ev2m7"
+  def self.base36(n = 16)
+    SecureRandom.random_bytes(n).unpack("C*").map do |byte|
+      idx = byte % 64
+      idx = SecureRandom.random_number(36) if idx >= 36
+      BASE36_ALPHABET[idx]
+    end.join
+  end
 end

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

@@ -75,6 +75,10 @@ class String
   #   str.first(0) # => ""
   #   str.first(6) # => "hello"
   def first(limit = 1)
+    ActiveSupport::Deprecation.warn(
+      "Calling String#first with a negative integer limit " \
+      "will raise an ArgumentError in Rails 6.1."
+    ) if limit < 0
     if limit == 0
       ""
     elsif limit >= size
@@ -95,6 +99,10 @@ class String
   #   str.last(0) # => ""
   #   str.last(6) # => "hello"
   def last(limit = 1)
+    ActiveSupport::Deprecation.warn(
+      "Calling String#last with a negative integer limit " \
+      "will raise an ArgumentError in Rails 6.1."
+    ) if limit < 0
     if limit == 0
       ""
     elsif limit >= size

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

@@ -78,6 +78,47 @@ class String
     "#{self[0, stop]}#{omission}"
   end
 
+  # Truncates +text+ to at most <tt>bytesize</tt> bytes in length without
+  # breaking string encoding by splitting multibyte characters or breaking
+  # grapheme clusters ("perceptual characters") by truncating at combining
+  # characters.
+  #
+  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".size
+  #   => 20
+  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".bytesize
+  #   => 80
+  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".truncate_bytes(20)
+  #   => "🔪🔪🔪🔪…"
+  #
+  # The truncated text ends with the <tt>:omission</tt> string, defaulting
+  # to "…", for a total length not exceeding <tt>bytesize</tt>.
+  def truncate_bytes(truncate_at, omission: "…")
+    omission ||= ""
+
+    case
+    when bytesize <= truncate_at
+      dup
+    when omission.bytesize > truncate_at
+      raise ArgumentError, "Omission #{omission.inspect} is #{omission.bytesize}, larger than the truncation length of #{truncate_at} bytes"
+    when omission.bytesize == truncate_at
+      omission.dup
+    else
+      self.class.new.tap do |cut|
+        cut_at = truncate_at - omission.bytesize
+
+        scan(/\X/) do |grapheme|
+          if cut.bytesize + grapheme.bytesize <= cut_at
+            cut << grapheme
+          else
+            break
+          end
+        end
+
+        cut << omission
+      end
+    end
+  end
+
   # Truncates a given +text+ after a given number of words (<tt>words_count</tt>):
   #
   #   'Once upon a time in a world far far away'.truncate_words(4)

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

@@ -11,12 +11,13 @@ class String
   # encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy
   # class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsulated string.
   #
-  #   >> "lj".upcase
-  #   => "lj"
   #   >> "lj".mb_chars.upcase.to_s
   #   => "LJ"
   #
-  # NOTE: An above example is useful for pre Ruby 2.4. Ruby 2.4 supports Unicode case mappings.
+  # NOTE: Ruby 2.4 and later support native Unicode case mappings:
+  #
+  #   >> "lj".upcase
+  #   => "LJ"
   #
   # == Method chaining
   #

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

@@ -134,8 +134,9 @@ end
 module ActiveSupport #:nodoc:
   class SafeBuffer < String
     UNSAFE_STRING_METHODS = %w(
-      capitalize chomp chop delete downcase gsub lstrip next reverse rstrip
-      slice squeeze strip sub succ swapcase tr tr_s upcase
+      capitalize chomp chop delete delete_prefix delete_suffix
+      downcase gsub lstrip next reverse rstrip slice squeeze strip
+      sub succ swapcase tr tr_s unicode_normalize upcase
     )
 
     alias_method :original_concat, :concat
@@ -149,9 +150,7 @@ module ActiveSupport #:nodoc:
     end
 
     def [](*args)
-      if args.size < 2
-        super
-      elsif html_safe?
+      if html_safe?
         new_safe_buffer = super
 
         if new_safe_buffer
@@ -188,10 +187,22 @@ module ActiveSupport #:nodoc:
     end
     alias << concat
 
+    def insert(index, value)
+      super(index, html_escape_interpolated_argument(value))
+    end
+
     def prepend(value)
       super(html_escape_interpolated_argument(value))
     end
 
+    def replace(value)
+      super(html_escape_interpolated_argument(value))
+    end
+
+    def []=(index, value)
+      super(index, html_escape_interpolated_argument(value))
+    end
+
     def +(other)
       dup.concat(other)
     end

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

@@ -20,6 +20,8 @@ class String
   # Technically, it looks for the least indented non-empty line
   # in the whole string, and removes that amount of leading whitespace.
   def strip_heredoc
-    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "".freeze)
+    gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "").tap do |stripped|
+      stripped.freeze if frozen?
+    end
   end
 end

data/lib/active_support/core_ext/uri.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "uri"
+
 if RUBY_VERSION < "2.6.0"
   require "active_support/core_ext/module/redefine_method"
   URI::Parser.class_eval do

data/lib/active_support/current_attributes.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/callbacks"
+
 module ActiveSupport
   # Abstract super class that provides a thread-isolated attributes singleton, which resets automatically
   # before and after each request. This allows you to keep all the per-request attributes easily

data/lib/active_support/dependencies.rb

@@ -79,6 +79,12 @@ module ActiveSupport #:nodoc:
     # to allow arbitrary constants to be marked for unloading.
     mattr_accessor :explicitly_unloadable_constants, default: []
 
+    # The logger used when tracing autoloads.
+    mattr_accessor :logger
+
+    # If true, trace autoloads with +logger.debug+.
+    mattr_accessor :verbose, default: false
+
     # The WatchStack keeps a stack of the modules being watched as files are
     # loaded. If a file in the process of being loaded (parent.rb) triggers the
     # load of another file (child.rb) the stack will ensure that child.rb
@@ -140,7 +146,7 @@ module ActiveSupport #:nodoc:
 
           # Normalize the list of new constants, and add them to the list we will return
           new_constants.each do |suffix|
-            constants << ([namespace, suffix] - ["Object"]).join("::".freeze)
+            constants << ([namespace, suffix] - ["Object"]).join("::")
           end
         end
         constants
@@ -349,7 +355,7 @@ module ActiveSupport #:nodoc:
     end
 
     def require_or_load(file_name, const_path = nil)
-      file_name = $` if file_name =~ /\.rb\z/
+      file_name = file_name.chomp(".rb")
       expanded = File.expand_path(file_name)
       return if loaded.include?(expanded)
 
@@ -399,7 +405,7 @@ module ActiveSupport #:nodoc:
     # constant paths which would cause Dependencies to attempt to load this
     # file.
     def loadable_constants_for_path(path, bases = autoload_paths)
-      path = $` if path =~ /\.rb\z/
+      path = path.chomp(".rb")
       expanded_path = File.expand_path(path)
       paths = []
 
@@ -408,7 +414,7 @@ module ActiveSupport #:nodoc:
         next unless expanded_path.start_with?(expanded_root)
 
         root_size = expanded_root.size
-        next if expanded_path[root_size] != ?/.freeze
+        next if expanded_path[root_size] != ?/
 
         nesting = expanded_path[(root_size + 1)..-1]
         paths << nesting.camelize unless nesting.blank?
@@ -420,7 +426,7 @@ module ActiveSupport #:nodoc:
 
     # Search for a file in autoload_paths matching the provided suffix.
     def search_for_file(path_suffix)
-      path_suffix = path_suffix.sub(/(\.rb)?$/, ".rb".freeze)
+      path_suffix += ".rb" unless path_suffix.ends_with?(".rb")
 
       autoload_paths.each do |root|
         path = File.join(root, path_suffix)
@@ -454,6 +460,7 @@ module ActiveSupport #:nodoc:
       return nil unless base_path = autoloadable_module?(path_suffix)
       mod = Module.new
       into.const_set const_name, mod
+      log("constant #{qualified_name} autoloaded (module autovivified from #{File.join(base_path, path_suffix)})")
       autoloaded_constants << qualified_name unless autoload_once_paths.include?(base_path)
       autoloaded_constants.uniq!
       mod
@@ -495,26 +502,31 @@ module ActiveSupport #:nodoc:
         raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
       end
 
-      qualified_name = qualified_name_for from_mod, const_name
+      qualified_name = qualified_name_for(from_mod, const_name)
       path_suffix = qualified_name.underscore
 
       file_path = search_for_file(path_suffix)
 
       if file_path
         expanded = File.expand_path(file_path)
-        expanded.sub!(/\.rb\z/, "".freeze)
+        expanded.sub!(/\.rb\z/, "")
 
         if loading.include?(expanded)
           raise "Circular dependency detected while autoloading constant #{qualified_name}"
         else
           require_or_load(expanded, qualified_name)
-          raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{file_path} to define it" unless from_mod.const_defined?(const_name, false)
-          return from_mod.const_get(const_name)
+
+          if from_mod.const_defined?(const_name, false)
+            log("constant #{qualified_name} autoloaded from #{expanded}.rb")
+            return from_mod.const_get(const_name)
+          else
+            raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{file_path} to define it"
+          end
         end
       elsif mod = autoload_module!(from_mod, const_name, qualified_name, path_suffix)
         return mod
-      elsif (parent = from_mod.parent) && parent != from_mod &&
-            ! from_mod.parents.any? { |p| p.const_defined?(const_name, false) }
+      elsif (parent = from_mod.module_parent) && parent != from_mod &&
+            ! from_mod.module_parents.any? { |p| p.const_defined?(const_name, false) }
         # If our parents do not have a constant named +const_name+ then we are free
         # to attempt to load upwards. If they do have such a constant, then this
         # const_missing must be due to from_mod::const_name, which should not
@@ -558,6 +570,7 @@ module ActiveSupport #:nodoc:
     # as the environment will be in an inconsistent state, e.g. other constants
     # may have already been unloaded and not accessible.
     def remove_unloadable_constants!
+      log("removing unloadable constants")
       autoloaded_constants.each { |const| remove_constant const }
       autoloaded_constants.clear
       Reference.clear!
@@ -747,6 +760,10 @@ module ActiveSupport #:nodoc:
         # The constant is no longer reachable, just skip it.
       end
     end
+
+    def log(message)
+      logger.debug("autoloading: #{message}") if logger && verbose
+    end
   end
 end