activesupport 6.0.0.beta3 → 6.0.0.rc1

data/lib/active_support/core_ext/enumerable.rb

@@ -97,23 +97,43 @@ module Enumerable
     end
   end
 
+  # Returns a new array that includes the passed elements.
+  #
+  #   [ 1, 2, 3 ].including(4, 5)
+  #   # => [ 1, 2, 3, 4, 5 ]
+  #
+  #   ["David", "Rafael"].including %w[ Aaron Todd ]
+  #   # => ["David", "Rafael", "Aaron", "Todd"]
+  def including(*elements)
+    to_a.including(*elements)
+  end
+
   # The negative of the <tt>Enumerable#include?</tt>. Returns +true+ if the
   # collection does not include the object.
   def exclude?(object)
     !include?(object)
   end
 
-  # Returns a copy of the enumerable without the specified elements.
+  # Returns a copy of the enumerable excluding the specified elements.
+  #
+  #   ["David", "Rafael", "Aaron", "Todd"].excluding "Aaron", "Todd"
+  #   # => ["David", "Rafael"]
   #
-  #   ["David", "Rafael", "Aaron", "Todd"].without "Aaron", "Todd"
+  #   ["David", "Rafael", "Aaron", "Todd"].excluding %w[ Aaron Todd ]
   #   # => ["David", "Rafael"]
   #
-  #   {foo: 1, bar: 2, baz: 3}.without :bar
+  #   {foo: 1, bar: 2, baz: 3}.excluding :bar
   #   # => {foo: 1, baz: 3}
-  def without(*elements)
+  def excluding(*elements)
+    elements.flatten!(1)
     reject { |element| elements.include?(element) }
   end
 
+  # Alias for #excluding.
+  def without(*elements)
+    excluding(*elements)
+  end
+
   # Convert an enumerable to an array based on the given key.
   #
   #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name)

data/lib/active_support/core_ext/hash/except.rb

@@ -10,7 +10,7 @@ class Hash
   # This is useful for limiting a set of parameters to everything but a few known toggles:
   #   @person.update(params[:person].except(:admin))
   def except(*keys)
-    dup.except!(*keys)
+    slice(*self.keys - keys)
   end
 
   # Removes the given keys from hash and returns it.

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

@@ -24,7 +24,7 @@ class Module
   #   end
   #   # => NameError: invalid attribute name: 1_Badname
   #
-  # If you want to opt out the creation on the instance reader method, pass
+  # To omit the instance reader method, pass
   # <tt>instance_reader: false</tt> or <tt>instance_accessor: false</tt>.
   #
   #   module HairColors
@@ -91,7 +91,7 @@ class Module
   #   Person.new.hair_colors = [:blonde, :red]
   #   HairColors.class_variable_get("@@hair_colors") # => [:blonde, :red]
   #
-  # If you want to opt out the instance writer method, pass
+  # To omit the instance writer method, pass
   # <tt>instance_writer: false</tt> or <tt>instance_accessor: false</tt>.
   #
   #   module HairColors
@@ -166,8 +166,8 @@ class Module
   #   Citizen.new.hair_colors << :blue
   #   Person.new.hair_colors # => [:brown, :black, :blonde, :red, :blue]
   #
-  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
-  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
+  # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
   #
   #   module HairColors
   #     mattr_accessor :hair_colors, instance_writer: false, instance_reader: false
@@ -180,7 +180,7 @@ class Module
   #   Person.new.hair_colors = [:brown]  # => NoMethodError
   #   Person.new.hair_colors             # => NoMethodError
   #
-  # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
+  # Or pass <tt>instance_accessor: false</tt>, to omit both instance methods.
   #
   #   module HairColors
   #     mattr_accessor :hair_colors, instance_accessor: false

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

@@ -25,7 +25,7 @@ class Module
   #   end
   #   # => NameError: invalid attribute name: 1_Badname
   #
-  # If you want to opt out of the creation of the instance reader method, pass
+  # To omit the instance reader method, pass
   # <tt>instance_reader: false</tt> or <tt>instance_accessor: false</tt>.
   #
   #   class Current
@@ -66,7 +66,7 @@ class Module
   #   Current.user = "DHH"
   #   Thread.current[:attr_Current_user] # => "DHH"
   #
-  # If you want to opt out of the creation of the instance writer method, pass
+  # To omit the instance writer method, pass
   # <tt>instance_writer: false</tt> or <tt>instance_accessor: false</tt>.
   #
   #   class Current
@@ -118,8 +118,8 @@ class Module
   #   Customer.user # => "Rafael"
   #   Account.user  # => "DHH"
   #
-  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
-  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
+  # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
   #
   #   class Current
   #     thread_mattr_accessor :user, instance_writer: false, instance_reader: false
@@ -128,7 +128,7 @@ class Module
   #   Current.new.user = "DHH"  # => NoMethodError
   #   Current.new.user          # => NoMethodError
   #
-  # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
+  # Or pass <tt>instance_accessor: false</tt>, to omit both instance methods.
   #
   #   class Current
   #     thread_mattr_accessor :user, instance_accessor: false

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

@@ -3,9 +3,10 @@
 module ActiveSupport
   module CompareWithRange
     # Extends the default Range#=== to support range comparisons.
-    #  (1..5) === (1..5) # => true
-    #  (1..5) === (2..3) # => true
-    #  (1..5) === (2..6) # => false
+    #  (1..5) === (1..5)  # => true
+    #  (1..5) === (2..3)  # => true
+    #  (1..5) === (1...6) # => true
+    #  (1..5) === (2..6)  # => false
     #
     # The native Range#=== behavior is untouched.
     #  ('a'..'f') === ('c') # => true
@@ -13,17 +14,20 @@ module ActiveSupport
     def ===(value)
       if value.is_a?(::Range)
         # 1...10 includes 1..9 but it does not include 1..10.
+        # 1..10 includes 1...11 but it does not include 1...12.
         operator = exclude_end? && !value.exclude_end? ? :< : :<=
-        super(value.first) && value.last.send(operator, last)
+        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
+        super(value.first) && value_max.send(operator, last)
       else
         super
       end
     end
 
     # Extends the default Range#include? to support range comparisons.
-    #  (1..5).include?(1..5) # => true
-    #  (1..5).include?(2..3) # => true
-    #  (1..5).include?(2..6) # => false
+    #  (1..5).include?(1..5)  # => true
+    #  (1..5).include?(2..3)  # => true
+    #  (1..5).include?(1...6) # => true
+    #  (1..5).include?(2..6)  # => false
     #
     # The native Range#include? behavior is untouched.
     #  ('a'..'f').include?('c') # => true
@@ -31,17 +35,20 @@ module ActiveSupport
     def include?(value)
       if value.is_a?(::Range)
         # 1...10 includes 1..9 but it does not include 1..10.
+        # 1..10 includes 1...11 but it does not include 1...12.
         operator = exclude_end? && !value.exclude_end? ? :< : :<=
-        super(value.first) && value.last.send(operator, last)
+        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
+        super(value.first) && value_max.send(operator, last)
       else
         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?(2..6) # => false
+    #  (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
@@ -49,8 +56,10 @@ module ActiveSupport
     def cover?(value)
       if value.is_a?(::Range)
         # 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? ? :< : :<=
-        super(value.first) && value.last.send(operator, last)
+        value_max = !exclude_end? && value.exclude_end? ? value.max : value.last
+        super(value.first) && value_max.send(operator, last)
       else
         super
       end

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

@@ -162,6 +162,11 @@ class String
 
   # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
   #
+  # If the optional parameter +locale+ is specified,
+  # the word will be parameterized as a word of that language.
+  # By default, this parameter is set to <tt>nil</tt> and it will use
+  # the configured <tt>I18n.locale</tt>.
+  #
   #   class Person
   #     def to_param
   #       "#{id}-#{name.parameterize}"
@@ -187,8 +192,8 @@ class String
   #
   #   <%= link_to(@person.name, person_path) %>
   #   # => <a href="/person/1-Donald-E-Knuth">Donald E. Knuth</a>
-  def parameterize(separator: "-", preserve_case: false)
-    ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case)
+  def parameterize(separator: "-", preserve_case: false, locale: nil)
+    ActiveSupport::Inflector.parameterize(self, separator: separator, preserve_case: preserve_case, locale: locale)
   end
 
   # Creates the name of a table like Rails does for models to table names. This method

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

@@ -135,10 +135,12 @@ module ActiveSupport #:nodoc:
   class SafeBuffer < String
     UNSAFE_STRING_METHODS = %w(
       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
+      downcase lstrip next reverse rstrip slice squeeze strip
+      succ swapcase tr tr_s unicode_normalize upcase
     )
 
+    UNSAFE_STRING_METHODS_WITH_BACKREF = %w(gsub sub)
+
     alias_method :original_concat, :concat
     private :original_concat
 
@@ -199,14 +201,24 @@ module ActiveSupport #:nodoc:
       super(html_escape_interpolated_argument(value))
     end
 
-    def []=(index, value)
-      super(index, html_escape_interpolated_argument(value))
+    def []=(*args)
+      if args.count == 3
+        super(args[0], args[1], html_escape_interpolated_argument(args[2]))
+      else
+        super(args[0], html_escape_interpolated_argument(args[1]))
+      end
     end
 
     def +(other)
       dup.concat(other)
     end
 
+    def *(*)
+      new_safe_buffer = super
+      new_safe_buffer.instance_variable_set(:@html_safe, @html_safe)
+      new_safe_buffer
+    end
+
     def %(args)
       case args
       when Hash
@@ -249,11 +261,44 @@ module ActiveSupport #:nodoc:
       end
     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
+    end
+
     private
 
       def html_escape_interpolated_argument(arg)
         (!html_safe? || arg.html_safe?) ? arg : CGI.escapeHTML(arg.to_s)
       end
+
+      def set_block_back_references(block, match_data)
+        block.binding.eval("proc { |m| $~ = m }").call(match_data)
+      end
   end
 end
 

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

@@ -170,8 +170,7 @@ class Time
       options[:hours] = options.fetch(:hours, 0) + 24 * partial_days
     end
 
-    d = to_date.advance(options)
-    d = d.gregorian if d.julian?
+    d = to_date.gregorian.advance(options)
     time_advanced_by_date = change(year: d.year, month: d.month, day: d.day)
     seconds_to_advance = \
       options.fetch(:seconds, 0) +

data/lib/active_support/dependencies.rb

@@ -70,6 +70,11 @@ module ActiveSupport #:nodoc:
     # only once. All directories in this set must also be present in +autoload_paths+.
     mattr_accessor :autoload_once_paths, default: []
 
+    # This is a private set that collects all eager load paths during bootstrap.
+    # Useful for Zeitwerk integration. Its public interface is the config.* path
+    # accessors of each engine.
+    mattr_accessor :_eager_load_paths, default: Set.new
+
     # An array of qualified constant names that have been loaded. Adding a name
     # to this array will cause it to be unloaded the next time Dependencies are
     # cleared.

data/lib/active_support/dependencies/zeitwerk_integration.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require "active_support/core_ext/string/inflections"
 
 module ActiveSupport
@@ -9,6 +10,8 @@ module ActiveSupport
         def clear
           Dependencies.unload_interlock do
             Rails.autoloaders.main.reload
+          rescue Zeitwerk::ReloadingDisabledError
+            raise "reloading is disabled because config.cache_classes is true"
           end
         end
 
@@ -21,12 +24,12 @@ module ActiveSupport
         end
 
         def autoloaded_constants
-          (Rails.autoloaders.main.loaded + Rails.autoloaders.once.loaded).to_a
+          Rails.autoloaders.main.unloadable_cpaths
         end
 
         def autoloaded?(object)
           cpath = object.is_a?(Module) ? object.name : object.to_s
-          Rails.autoloaders.any? { |autoloader| autoloader.loaded?(cpath) }
+          Rails.autoloaders.main.unloadable_cpath?(cpath)
         end
 
         def verbose=(verbose)
@@ -46,42 +49,43 @@ module ActiveSupport
       end
 
       class << self
-        def take_over
-          setup_autoloaders
-          freeze_autoload_paths
+        def take_over(enable_reloading:)
+          setup_autoloaders(enable_reloading)
+          freeze_paths
           decorate_dependencies
         end
 
         private
 
-          def setup_autoloaders
-            Rails.autoloaders.each do |autoloader|
-              autoloader.inflector = Inflector
-            end
-
+          def setup_autoloaders(enable_reloading)
             Dependencies.autoload_paths.each do |autoload_path|
               # Zeitwerk only accepts existing directories in `push_dir` to
               # prevent misconfigurations.
               next unless File.directory?(autoload_path)
 
-              if autoload_once?(autoload_path)
-                Rails.autoloaders.once.push_dir(autoload_path)
-              else
-                Rails.autoloaders.main.push_dir(autoload_path)
-              end
+              autoloader = \
+                autoload_once?(autoload_path) ? Rails.autoloaders.once : Rails.autoloaders.main
+
+              autoloader.push_dir(autoload_path)
+              autoloader.do_not_eager_load(autoload_path) unless eager_load?(autoload_path)
             end
 
+            Rails.autoloaders.main.enable_reloading if enable_reloading
             Rails.autoloaders.each(&:setup)
           end
 
           def autoload_once?(autoload_path)
-            Dependencies.autoload_once_paths.include?(autoload_path) ||
-            Gem.path.any? { |gem_path| autoload_path.to_s.start_with?(gem_path) }
+            Dependencies.autoload_once_paths.include?(autoload_path)
+          end
+
+          def eager_load?(autoload_path)
+            Dependencies._eager_load_paths.member?(autoload_path)
           end
 
-          def freeze_autoload_paths
+          def freeze_paths
             Dependencies.autoload_paths.freeze
             Dependencies.autoload_once_paths.freeze
+            Dependencies._eager_load_paths.freeze
           end
 
           def decorate_dependencies

data/lib/active_support/deprecation/method_wrappers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/module/redefine_method"
 
 module ActiveSupport
   class Deprecation
@@ -52,29 +53,17 @@ module ActiveSupport
         options = method_names.extract_options!
         deprecator = options.delete(:deprecator) || self
         method_names += options.keys
-        mod = Module.new
+        mod = nil
 
         method_names.each do |method_name|
           if target_module.method_defined?(method_name) || target_module.private_method_defined?(method_name)
-            aliased_method, punctuation = method_name.to_s.sub(/([?!=])$/, ""), $1
-            with_method = "#{aliased_method}_with_deprecation#{punctuation}"
-            without_method = "#{aliased_method}_without_deprecation#{punctuation}"
-
-            target_module.define_method(with_method) do |*args, &block|
+            method = target_module.instance_method(method_name)
+            target_module.redefine_method(method_name) do |*args, &block|
               deprecator.deprecation_warning(method_name, options[method_name])
-              send(without_method, *args, &block)
-            end
-
-            target_module.alias_method(without_method, method_name)
-            target_module.alias_method(method_name, with_method)
-
-            case
-            when target_module.protected_method_defined?(without_method)
-              target_module.send(:protected, method_name)
-            when target_module.private_method_defined?(without_method)
-              target_module.send(:private, method_name)
+              method.bind(self).call(*args, &block)
             end
           else
+            mod ||= Module.new
             mod.define_method(method_name) do |*args, &block|
               deprecator.deprecation_warning(method_name, options[method_name])
               super(*args, &block)
@@ -82,7 +71,7 @@ module ActiveSupport
           end
         end
 
-        target_module.prepend(mod) unless mod.instance_methods(false).empty?
+        target_module.prepend(mod) if mod
       end
     end
   end