activesupport 6.0.0.beta2 → 6.0.2.rc1

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

@@ -3,54 +3,69 @@
 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
     #  (5..9) === (11) # => false
+    #
+    # The given range must be fully bounded, with both start and end.
     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) && (self.end.nil? || 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
     #  (5..9).include?(11) # => false
+    #
+    # The given range must be fully bounded, with both start and end.
     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) && (self.end.nil? || 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
     #  (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)
         # 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) && (self.end.nil? || value_max.send(operator, last))
       else
         super
       end

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

@@ -9,9 +9,9 @@ module ActiveSupport
     #   (1.hour.ago..1.hour.from_now).include?(Time.current) # => true
     #
     def include?(value)
-      if first.is_a?(TimeWithZone)
+      if self.begin.is_a?(TimeWithZone)
         cover?(value)
-      elsif last.is_a?(TimeWithZone)
+      elsif self.end.is_a?(TimeWithZone)
         cover?(value)
       else
         super

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

@@ -75,7 +75,7 @@ class String
         length_with_room_for_omission
       end
 
-    "#{self[0, stop]}#{omission}"
+    +"#{self[0, stop]}#{omission}"
   end
 
   # Truncates +text+ to at most <tt>bytesize</tt> bytes in length without

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,46 @@ 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)
+      rescue ArgumentError
+        # Can't create binding from C level Proc
+      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) +
@@ -312,4 +311,34 @@ class Time
   end
   alias_method :eql_without_coercion, :eql?
   alias_method :eql?, :eql_with_coercion
+
+  # Returns a new time the specified number of days ago.
+  def prev_day(days = 1)
+    advance(days: -days)
+  end
+
+  # Returns a new time the specified number of days in the future.
+  def next_day(days = 1)
+    advance(days: days)
+  end
+
+  # Returns a new time the specified number of months ago.
+  def prev_month(months = 1)
+    advance(months: -months)
+  end
+
+  # Returns a new time the specified number of months in the future.
+  def next_month(months = 1)
+    advance(months: months)
+  end
+
+  # Returns a new time the specified number of years ago.
+  def prev_year(years = 1)
+    advance(years: -years)
+  end
+
+  # Returns a new time the specified number of years in the future.
+  def next_year(years = 1)
+    advance(years: years)
+  end
 end

data/lib/active_support/dependencies.rb

@@ -20,6 +20,9 @@ module ActiveSupport #:nodoc:
   module Dependencies #:nodoc:
     extend self
 
+    UNBOUND_METHOD_MODULE_NAME = Module.instance_method(:name)
+    private_constant :UNBOUND_METHOD_MODULE_NAME
+
     mattr_accessor :interlock, default: Interlock.new
 
     # :doc:
@@ -70,6 +73,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.
@@ -196,6 +204,11 @@ module ActiveSupport #:nodoc:
         end
       end
 
+      def self.include_into(base)
+        base.include(self)
+        append_features(base)
+      end
+
       def const_missing(const_name)
         from_mod = anonymous? ? guess_for_anonymous(const_name) : self
         Dependencies.load_missing_constant(from_mod, const_name)
@@ -225,6 +238,21 @@ module ActiveSupport #:nodoc:
         base.class_eval do
           define_method(:load, Kernel.instance_method(:load))
           private :load
+
+          define_method(:require, Kernel.instance_method(:require))
+          private :require
+        end
+      end
+
+      def self.include_into(base)
+        base.include(self)
+
+        if base.instance_method(:load).owner == base
+          base.remove_method(:load)
+        end
+
+        if base.instance_method(:require).owner == base
+          base.remove_method(:require)
         end
       end
 
@@ -321,9 +349,9 @@ module ActiveSupport #:nodoc:
     end
 
     def hook!
-      Object.class_eval { include Loadable }
-      Module.class_eval { include ModuleConstMissing }
-      Exception.class_eval { include Blamable }
+      Loadable.include_into(Object)
+      ModuleConstMissing.include_into(Module)
+      Exception.include(Blamable)
     end
 
     def unhook!
@@ -634,7 +662,7 @@ module ActiveSupport #:nodoc:
 
     # Determine if the given constant has been automatically loaded.
     def autoloaded?(desc)
-      return false if desc.is_a?(Module) && desc.anonymous?
+      return false if desc.is_a?(Module) && real_mod_name(desc).nil?
       name = to_constant_name desc
       return false unless qualified_const_defined?(name)
       autoloaded_constants.include?(name)
@@ -690,7 +718,7 @@ module ActiveSupport #:nodoc:
       when String then desc.sub(/^::/, "")
       when Symbol then desc.to_s
       when Module
-        desc.name ||
+        real_mod_name(desc) ||
           raise(ArgumentError, "Anonymous modules have no name to be referenced by")
       else raise TypeError, "Not a valid constant descriptor: #{desc.inspect}"
       end
@@ -764,6 +792,14 @@ module ActiveSupport #:nodoc:
     def log(message)
       logger.debug("autoloading: #{message}") if logger && verbose
     end
+
+    private
+
+      # Returns the original name of a class or module even if `name` has been
+      # overridden.
+      def real_mod_name(mod)
+        UNBOUND_METHOD_MODULE_NAME.bind(mod).call
+      end
   end
 end
 

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) }
+          cpath = object.is_a?(Module) ? real_mod_name(object) : object.to_s
+          Rails.autoloaders.main.unloadable_cpath?(cpath)
         end
 
         def verbose=(verbose)
@@ -39,55 +42,75 @@ module ActiveSupport
         end
       end
 
+      module RequireDependency
+        def require_dependency(filename)
+          filename = filename.to_path if filename.respond_to?(:to_path)
+          if abspath = ActiveSupport::Dependencies.search_for_file(filename)
+            require abspath
+          else
+            require filename
+          end
+        end
+      end
+
       module Inflector
+        # Concurrent::Map is not needed. This is a private class, and overrides
+        # must be defined while the application boots.
+        @overrides = {}
+
         def self.camelize(basename, _abspath)
-          basename.camelize
+          @overrides[basename] || basename.camelize
+        end
+
+        def self.inflect(overrides)
+          @overrides.merge!(overrides)
         end
       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
             Dependencies.unhook!
             Dependencies.singleton_class.prepend(Decorations)
-            Object.class_eval { alias_method :require_dependency, :require }
+            Object.prepend(RequireDependency)
           end
       end
     end