activesupport 5.2.7.1 → 6.1.4.6

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 class String
-  alias_method :starts_with?, :start_with?
-  alias_method :ends_with?, :end_with?
+  alias :starts_with? :start_with?
+  alias :ends_with? :end_with?
 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/symbol/starts_ends_with.rb

@@ -0,0 +1,14 @@
+# 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/symbol.rb

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

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

@@ -6,6 +6,7 @@ require "active_support/time_with_zone"
 require "active_support/core_ext/time/zones"
 require "active_support/core_ext/date_and_time/calculations"
 require "active_support/core_ext/date/calculations"
+require "active_support/core_ext/module/remove_method"
 
 class Time
   include DateAndTime::Calculations
@@ -47,12 +48,15 @@ class Time
       # Time.at can be called with a time or numerical value
       time_or_number = args.first
 
-      if time_or_number.is_a?(ActiveSupport::TimeWithZone) || time_or_number.is_a?(DateTime)
+      if time_or_number.is_a?(ActiveSupport::TimeWithZone)
+        at_without_coercion(time_or_number.to_r).getlocal
+      elsif time_or_number.is_a?(DateTime)
         at_without_coercion(time_or_number.to_f).getlocal
       else
         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
 
@@ -105,6 +109,21 @@ class Time
     subsec
   end
 
+  unless Time.method_defined?(:floor)
+    def floor(precision = 0)
+      change(nsec: 0) + subsec.floor(precision)
+    end
+  end
+
+  # Restricted Ruby version due to a bug in `Time#ceil`
+  # See https://bugs.ruby-lang.org/issues/17025 for more details
+  if RUBY_VERSION <= "2.8"
+    remove_possible_method :ceil
+    def ceil(precision = 0)
+      change(nsec: 0) + subsec.ceil(precision)
+    end
+  end
+
   # 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
@@ -170,8 +189,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 +330,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/core_ext/time/conversions.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require "time"
 require "active_support/inflector/methods"
 require "active_support/values/time_zone"
 
 class Time
   DATE_FORMATS = {
     db: "%Y-%m-%d %H:%M:%S",
+    inspect: "%Y-%m-%d %H:%M:%S.%9N %z",
     number: "%Y%m%d%H%M%S",
     nsec: "%Y%m%d%H%M%S%9N",
     usec: "%Y%m%d%H%M%S%6N",

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
@@ -18,7 +19,11 @@ end
 module URI
   class << self
     def parser
-      @parser ||= URI::Parser.new
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+        URI.parser is deprecated and will be removed in Rails 6.2.
+        Use `URI::DEFAULT_PARSER` instead.
+      MSG
+      URI::DEFAULT_PARSER
     end
   end
 end

data/lib/active_support/core_ext.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).each do |path|
+Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort.each do |path|
   require path
 end

data/lib/active_support/current_attributes/test_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveSupport::CurrentAttributes::TestHelper # :nodoc:
+  def before_setup
+    ActiveSupport::CurrentAttributes.reset_all
+    super
+  end
+
+  def after_teardown
+    super
+    ActiveSupport::CurrentAttributes.reset_all
+  end
+end

data/lib/active_support/current_attributes.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "active_support/callbacks"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/module/delegation"
+
 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
@@ -89,7 +93,7 @@ module ActiveSupport
     class << self
       # Returns singleton instance for this class in this thread. If none exists, one is created.
       def instance
-        current_instances[name] ||= new
+        current_instances[current_instances_key] ||= new
       end
 
       # Declares one or more attributes that will be given both class and instance accessor methods.
@@ -117,10 +121,16 @@ module ActiveSupport
         end
       end
 
+      # Calls this block before #reset is called on the instance. Used for resetting external collaborators that depend on current values.
+      def before_reset(&block)
+        set_callback :reset, :before, &block
+      end
+
       # Calls this block after #reset is called on the instance. Used for resetting external collaborators, like Time.zone.
       def resets(&block)
         set_callback :reset, :after, &block
       end
+      alias_method :after_reset, :resets
 
       delegate :set, :reset, to: :instance
 
@@ -142,6 +152,10 @@ module ActiveSupport
           Thread.current[:current_attributes_instances] ||= {}
         end
 
+        def current_instances_key
+          @current_instances_key ||= name.to_sym
+        end
+
         def method_missing(name, *args, &block)
           # Caches the method definition as a singleton method of the receiver.
           #
@@ -189,7 +203,7 @@ module ActiveSupport
       end
 
       def compute_attributes(keys)
-        keys.collect { |key| [ key, public_send(key) ] }.to_h
+        keys.index_with { |key| public_send(key) }
       end
   end
 end

data/lib/active_support/dependencies/zeitwerk_integration.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "set"
+require "active_support/core_ext/string/inflections"
+
+module ActiveSupport
+  module Dependencies
+    module ZeitwerkIntegration # :nodoc: all
+      module Decorations
+        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
+
+        def constantize(cpath)
+          ActiveSupport::Inflector.constantize(cpath)
+        end
+
+        def safe_constantize(cpath)
+          ActiveSupport::Inflector.safe_constantize(cpath)
+        end
+
+        def autoloaded_constants
+          Rails.autoloaders.main.unloadable_cpaths
+        end
+
+        def autoloaded?(object)
+          cpath = object.is_a?(Module) ? real_mod_name(object) : object.to_s
+          Rails.autoloaders.main.unloadable_cpath?(cpath)
+        end
+
+        def verbose=(verbose)
+          l = verbose ? logger || Rails.logger : nil
+          Rails.autoloaders.each { |autoloader| autoloader.logger = l }
+        end
+
+        def unhook!
+          :no_op
+        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)
+          @overrides[basename] || basename.camelize
+        end
+
+        def self.inflect(overrides)
+          @overrides.merge!(overrides)
+        end
+      end
+
+      class << self
+        def take_over(enable_reloading:)
+          setup_autoloaders(enable_reloading)
+          freeze_paths
+          decorate_dependencies
+        end
+
+        private
+          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)
+
+              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)
+          end
+
+          def eager_load?(autoload_path)
+            Dependencies._eager_load_paths.member?(autoload_path)
+          end
+
+          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.prepend(RequireDependency)
+          end
+      end
+    end
+  end
+end