activesupport 5.1.7 → 5.2.7

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/conversions"
 require "active_support/core_ext/time/zones"
 

data/lib/active_support/core_ext/string.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/conversions"
 require "active_support/core_ext/string/filters"
 require "active_support/core_ext/string/multibyte"

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/acts_like"
 
 class Time

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/duration"
 require "active_support/core_ext/time/conversions"
 require "active_support/time_with_zone"
@@ -107,21 +109,22 @@ class Time
   # 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
   # the hour is passed, then minute, sec, usec and nsec is set to 0. If the hour
-  # and minute is passed, then sec, usec and nsec is set to 0. The +options+
-  # parameter takes a hash with any of these keys: <tt>:year</tt>, <tt>:month</tt>,
-  # <tt>:day</tt>, <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>
-  # <tt>:nsec</tt>. Pass either <tt>:usec</tt> or <tt>:nsec</tt>, not both.
+  # and minute is passed, then sec, usec and nsec is set to 0. The +options+ parameter
+  # takes a hash with any of these keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>,
+  # <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>,
+  # <tt>:offset</tt>. Pass either <tt>:usec</tt> or <tt>:nsec</tt>, not both.
   #
   #   Time.new(2012, 8, 29, 22, 35, 0).change(day: 1)              # => Time.new(2012, 8, 1, 22, 35, 0)
   #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => Time.new(1981, 8, 1, 22, 35, 0)
   #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => Time.new(1981, 8, 29, 0, 0, 0)
   def change(options)
-    new_year  = options.fetch(:year, year)
-    new_month = options.fetch(:month, month)
-    new_day   = options.fetch(:day, day)
-    new_hour  = options.fetch(:hour, hour)
-    new_min   = options.fetch(:min, options[:hour] ? 0 : min)
-    new_sec   = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec)
+    new_year   = options.fetch(:year, year)
+    new_month  = options.fetch(:month, month)
+    new_day    = options.fetch(:day, day)
+    new_hour   = options.fetch(:hour, hour)
+    new_min    = options.fetch(:min, options[:hour] ? 0 : min)
+    new_sec    = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec)
+    new_offset = options.fetch(:offset, nil)
 
     if new_nsec = options[:nsec]
       raise ArgumentError, "Can't change both :nsec and :usec at the same time: #{options.inspect}" if options[:usec]
@@ -130,13 +133,18 @@ class Time
       new_usec = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
     end
 
-    if utc?
-      ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec)
+    raise ArgumentError, "argument out of range" if new_usec >= 1000000
+
+    new_sec += Rational(new_usec, 1000000)
+
+    if new_offset
+      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, new_offset)
+    elsif utc?
+      ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec)
     elsif zone
-      ::Time.local(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec)
+      ::Time.local(new_year, new_month, new_day, new_hour, new_min, new_sec)
     else
-      raise ArgumentError, "argument out of range" if new_usec >= 1000000
-      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec + (new_usec.to_r / 1000000), utc_offset)
+      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, utc_offset)
     end
   end
 

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/date_and_time/compatibility"
-require "active_support/core_ext/module/remove_method"
+require "active_support/core_ext/module/redefine_method"
 
 class Time
   include DateAndTime::Compatibility
 
-  remove_possible_method :to_time
+  silence_redefinition_of_method :to_time
 
   # Either return +self+ or the time in the local system timezone depending
   # on the setting of +ActiveSupport.to_time_preserves_timezone+.

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/inflector/methods"
 require "active_support/values/time_zone"
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/time_with_zone"
 require "active_support/core_ext/time/acts_like"
 require "active_support/core_ext/date_and_time/zones"
@@ -53,10 +55,10 @@ class Time
     #     end
     #   end
     #
-    #  NOTE: This won't affect any <tt>ActiveSupport::TimeWithZone</tt>
-    #  objects that have already been created, e.g. any model timestamp
-    #  attributes that have been read before the block will remain in
-    #  the application's default timezone.
+    # NOTE: This won't affect any <tt>ActiveSupport::TimeWithZone</tt>
+    # objects that have already been created, e.g. any model timestamp
+    # attributes that have been read before the block will remain in
+    # the application's default timezone.
     def use_zone(time_zone)
       new_zone = find_zone!(time_zone)
       begin

data/lib/active_support/core_ext/time.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/time/acts_like"
 require "active_support/core_ext/time/calculations"
 require "active_support/core_ext/time/compatibility"

data/lib/active_support/core_ext/uri.rb

@@ -1,16 +1,16 @@
-require "uri"
-str = "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E" # Ni-ho-nn-go in UTF-8, means Japanese.
-parser = URI::Parser.new
+# frozen_string_literal: true
 
-unless str == parser.unescape(parser.escape(str))
+require "uri"
+if RUBY_VERSION < "2.6.0"
+  require "active_support/core_ext/module/redefine_method"
   URI::Parser.class_eval do
-    remove_method :unescape
+    silence_redefinition_of_method :unescape
     def unescape(str, escaped = /%[a-fA-F\d]{2}/)
       # TODO: Are we actually sure that ASCII == UTF-8?
       # YK: My initial experiments say yes, but let's be sure please
       enc = str.encoding
       enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
-      str.gsub(escaped) { |match| [match[1, 2].hex].pack("C") }.force_encoding(enc)
+      str.dup.force_encoding(Encoding::ASCII_8BIT).gsub(escaped) { |match| [match[1, 2].hex].pack("C") }.force_encoding(enc)
     end
   end
 end

data/lib/active_support/core_ext.rb

@@ -1,3 +1,5 @@
-(Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"]).each do |path|
+# frozen_string_literal: true
+
+Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).each do |path|
   require path
 end

data/lib/active_support/current_attributes.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+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
+  # available to the whole system.
+  #
+  # The following full app-like example demonstrates how to use a Current class to
+  # facilitate easy access to the global, per-request attributes without passing them deeply
+  # around everywhere:
+  #
+  #   # app/models/current.rb
+  #   class Current < ActiveSupport::CurrentAttributes
+  #     attribute :account, :user
+  #     attribute :request_id, :user_agent, :ip_address
+  #
+  #     resets { Time.zone = nil }
+  #
+  #     def user=(user)
+  #       super
+  #       self.account = user.account
+  #       Time.zone    = user.time_zone
+  #     end
+  #   end
+  #
+  #   # app/controllers/concerns/authentication.rb
+  #   module Authentication
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       before_action :authenticate
+  #     end
+  #
+  #     private
+  #       def authenticate
+  #         if authenticated_user = User.find_by(id: cookies.encrypted[:user_id])
+  #           Current.user = authenticated_user
+  #         else
+  #           redirect_to new_session_url
+  #         end
+  #       end
+  #   end
+  #
+  #   # app/controllers/concerns/set_current_request_details.rb
+  #   module SetCurrentRequestDetails
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       before_action do
+  #         Current.request_id = request.uuid
+  #         Current.user_agent = request.user_agent
+  #         Current.ip_address = request.ip
+  #       end
+  #     end
+  #   end
+  #
+  #   class ApplicationController < ActionController::Base
+  #     include Authentication
+  #     include SetCurrentRequestDetails
+  #   end
+  #
+  #   class MessagesController < ApplicationController
+  #     def create
+  #       Current.account.messages.create(message_params)
+  #     end
+  #   end
+  #
+  #   class Message < ApplicationRecord
+  #     belongs_to :creator, default: -> { Current.user }
+  #     after_create { |message| Event.create(record: message) }
+  #   end
+  #
+  #   class Event < ApplicationRecord
+  #     before_create do
+  #       self.request_id = Current.request_id
+  #       self.user_agent = Current.user_agent
+  #       self.ip_address = Current.ip_address
+  #     end
+  #   end
+  #
+  # A word of caution: It's easy to overdo a global singleton like Current and tangle your model as a result.
+  # Current should only be used for a few, top-level globals, like account, user, and request details.
+  # The attributes stuck in Current should be used by more or less all actions on all requests. If you start
+  # sticking controller-specific attributes in there, you're going to create a mess.
+  class CurrentAttributes
+    include ActiveSupport::Callbacks
+    define_callbacks :reset
+
+    class << self
+      # Returns singleton instance for this class in this thread. If none exists, one is created.
+      def instance
+        current_instances[name] ||= new
+      end
+
+      # Declares one or more attributes that will be given both class and instance accessor methods.
+      def attribute(*names)
+        generated_attribute_methods.module_eval do
+          names.each do |name|
+            define_method(name) do
+              attributes[name.to_sym]
+            end
+
+            define_method("#{name}=") do |attribute|
+              attributes[name.to_sym] = attribute
+            end
+          end
+        end
+
+        names.each do |name|
+          define_singleton_method(name) do
+            instance.public_send(name)
+          end
+
+          define_singleton_method("#{name}=") do |attribute|
+            instance.public_send("#{name}=", attribute)
+          end
+        end
+      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
+
+      delegate :set, :reset, to: :instance
+
+      def reset_all # :nodoc:
+        current_instances.each_value(&:reset)
+      end
+
+      def clear_all # :nodoc:
+        reset_all
+        current_instances.clear
+      end
+
+      private
+        def generated_attribute_methods
+          @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
+        end
+
+        def current_instances
+          Thread.current[:current_attributes_instances] ||= {}
+        end
+
+        def method_missing(name, *args, &block)
+          # Caches the method definition as a singleton method of the receiver.
+          #
+          # By letting #delegate handle it, we avoid an enclosure that'll capture args.
+          singleton_class.delegate name, to: :instance
+
+          send(name, *args, &block)
+        end
+    end
+
+    attr_accessor :attributes
+
+    def initialize
+      @attributes = {}
+    end
+
+    # Expose one or more attributes within a block. Old values are returned after the block concludes.
+    # Example demonstrating the common use of needing to set Current attributes outside the request-cycle:
+    #
+    #   class Chat::PublicationJob < ApplicationJob
+    #     def perform(attributes, room_number, creator)
+    #       Current.set(person: creator) do
+    #         Chat::Publisher.publish(attributes: attributes, room_number: room_number)
+    #       end
+    #     end
+    #   end
+    def set(set_attributes)
+      old_attributes = compute_attributes(set_attributes.keys)
+      assign_attributes(set_attributes)
+      yield
+    ensure
+      assign_attributes(old_attributes)
+    end
+
+    # Reset all attributes. Should be called before and after actions, when used as a per-request singleton.
+    def reset
+      run_callbacks :reset do
+        self.attributes = {}
+      end
+    end
+
+    private
+      def assign_attributes(new_attributes)
+        new_attributes.each { |key, value| public_send("#{key}=", value) }
+      end
+
+      def compute_attributes(keys)
+        keys.collect { |key| [ key, public_send(key) ] }.to_h
+      end
+  end
+end

data/lib/active_support/dependencies/autoload.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/inflector/methods"
 
 module ActiveSupport

data/lib/active_support/dependencies/interlock.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/concurrency/share_lock"
 
 module ActiveSupport #:nodoc:

data/lib/active_support/dependencies.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "set"
 require "thread"
 require "concurrent/map"
@@ -18,8 +20,7 @@ module ActiveSupport #:nodoc:
   module Dependencies #:nodoc:
     extend self
 
-    mattr_accessor :interlock
-    self.interlock = Interlock.new
+    mattr_accessor :interlock, default: Interlock.new
 
     # :doc:
 
@@ -46,46 +47,37 @@ module ActiveSupport #:nodoc:
     # :nodoc:
 
     # Should we turn on Ruby warnings on the first load of dependent files?
-    mattr_accessor :warnings_on_first_load
-    self.warnings_on_first_load = false
+    mattr_accessor :warnings_on_first_load, default: false
 
     # All files ever loaded.
-    mattr_accessor :history
-    self.history = Set.new
+    mattr_accessor :history, default: Set.new
 
     # All files currently loaded.
-    mattr_accessor :loaded
-    self.loaded = Set.new
+    mattr_accessor :loaded, default: Set.new
 
     # Stack of files being loaded.
-    mattr_accessor :loading
-    self.loading = []
+    mattr_accessor :loading, default: []
 
     # Should we load files or require them?
-    mattr_accessor :mechanism
-    self.mechanism = ENV["NO_RELOAD"] ? :require : :load
+    mattr_accessor :mechanism, default: ENV["NO_RELOAD"] ? :require : :load
 
     # The set of directories from which we may automatically load files. Files
     # under these directories will be reloaded on each request in development mode,
     # unless the directory also appears in autoload_once_paths.
-    mattr_accessor :autoload_paths
-    self.autoload_paths = []
+    mattr_accessor :autoload_paths, default: []
 
     # The set of directories from which automatically loaded constants are loaded
     # only once. All directories in this set must also be present in +autoload_paths+.
-    mattr_accessor :autoload_once_paths
-    self.autoload_once_paths = []
+    mattr_accessor :autoload_once_paths, default: []
 
     # 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.
-    mattr_accessor :autoloaded_constants
-    self.autoloaded_constants = []
+    mattr_accessor :autoloaded_constants, default: []
 
     # An array of constant names that need to be unloaded on every request. Used
     # to allow arbitrary constants to be marked for unloading.
-    mattr_accessor :explicitly_unloadable_constants
-    self.explicitly_unloadable_constants = []
+    mattr_accessor :explicitly_unloadable_constants, default: []
 
     # 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
@@ -93,7 +85,7 @@ module ActiveSupport #:nodoc:
     # handles the new constants.
     #
     # If child.rb is being autoloaded, its constants will be added to
-    # autoloaded_constants. If it was being `require`d, they will be discarded.
+    # autoloaded_constants. If it was being required, they will be discarded.
     #
     # This is handled by walking back up the watch stack and adding the constants
     # found by child.rb to the list of original constants in parent.rb.
@@ -105,6 +97,8 @@ module ActiveSupport #:nodoc:
       # parent.rb then requires namespace/child.rb, the stack will look like
       # [[Object], [Namespace]].
 
+      attr_reader :watching
+
       def initialize
         @watching = []
         @stack = Hash.new { |h, k| h[k] = [] }
@@ -175,8 +169,7 @@ module ActiveSupport #:nodoc:
     end
 
     # An internal stack used to record which constants are loaded by any block.
-    mattr_accessor :constant_watch_stack
-    self.constant_watch_stack = WatchStack.new
+    mattr_accessor :constant_watch_stack, default: WatchStack.new
 
     # Module includes this module.
     module ModuleConstMissing #:nodoc:
@@ -233,6 +226,8 @@ module ActiveSupport #:nodoc:
         Dependencies.require_or_load(file_name)
       end
 
+      # :doc:
+
       # Interprets a file using <tt>mechanism</tt> and marks its defined
       # constants as autoloaded. <tt>file_name</tt> can be either a string or
       # respond to <tt>to_path</tt>.
@@ -251,9 +246,13 @@ module ActiveSupport #:nodoc:
         Dependencies.depend_on(file_name, message)
       end
 
+      # :nodoc:
+
       def load_dependency(file)
         if Dependencies.load? && Dependencies.constant_watch_stack.watching?
-          Dependencies.new_constants_in(Object) { yield }
+          descs = Dependencies.constant_watch_stack.watching.flatten.uniq
+
+          Dependencies.new_constants_in(*descs) { yield }
         else
           yield
         end
@@ -625,7 +624,7 @@ module ActiveSupport #:nodoc:
       return false if desc.is_a?(Module) && desc.anonymous?
       name = to_constant_name desc
       return false unless qualified_const_defined?(name)
-      return autoloaded_constants.include?(name)
+      autoloaded_constants.include?(name)
     end
 
     # Will the provided constant descriptor be unloaded?
@@ -680,7 +679,7 @@ module ActiveSupport #:nodoc:
       when Module
         desc.name ||
           raise(ArgumentError, "Anonymous modules have no name to be referenced by")
-        else raise TypeError, "Not a valid constant descriptor: #{desc.inspect}"
+      else raise TypeError, "Not a valid constant descriptor: #{desc.inspect}"
       end
     end
 

data/lib/active_support/deprecation/behaviors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/notifications"
 
 module ActiveSupport
@@ -9,18 +11,18 @@ module ActiveSupport
   class Deprecation
     # Default warning behaviors per Rails.env.
     DEFAULT_BEHAVIORS = {
-      raise: ->(message, callstack) {
+      raise: ->(message, callstack, deprecation_horizon, gem_name) {
         e = DeprecationException.new(message)
         e.set_backtrace(callstack.map(&:to_s))
         raise e
       },
 
-      stderr: ->(message, callstack) {
+      stderr: ->(message, callstack, deprecation_horizon, gem_name) {
         $stderr.puts(message)
         $stderr.puts callstack.join("\n  ") if debug
       },
 
-      log: ->(message, callstack) {
+      log: ->(message, callstack, deprecation_horizon, gem_name) {
         logger =
             if defined?(Rails.logger) && Rails.logger
               Rails.logger
@@ -32,12 +34,16 @@ module ActiveSupport
         logger.debug callstack.join("\n  ") if debug
       },
 
-      notify: ->(message, callstack) {
-        ActiveSupport::Notifications.instrument("deprecation.rails",
-                                                message: message, callstack: callstack)
+      notify: ->(message, callstack, deprecation_horizon, gem_name) {
+        notification_name = "deprecation.#{gem_name.underscore.tr('/', '_')}"
+        ActiveSupport::Notifications.instrument(notification_name,
+                                                message: message,
+                                                callstack: callstack,
+                                                gem_name: gem_name,
+                                                deprecation_horizon: deprecation_horizon)
       },
 
-      silence: ->(message, callstack) {},
+      silence: ->(message, callstack, deprecation_horizon, gem_name) {},
     }
 
     # Behavior module allows to determine how to display deprecation messages.
@@ -79,12 +85,25 @@ module ActiveSupport
       #   ActiveSupport::Deprecation.behavior = :stderr
       #   ActiveSupport::Deprecation.behavior = [:stderr, :log]
       #   ActiveSupport::Deprecation.behavior = MyCustomHandler
-      #   ActiveSupport::Deprecation.behavior = ->(message, callstack) {
+      #   ActiveSupport::Deprecation.behavior = ->(message, callstack, deprecation_horizon, gem_name) {
       #     # custom stuff
       #   }
       def behavior=(behavior)
-        @behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || b }
+        @behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || arity_coerce(b) }
       end
+
+      private
+        def arity_coerce(behavior)
+          unless behavior.respond_to?(:call)
+            raise ArgumentError, "#{behavior.inspect} is not a valid deprecation behavior."
+          end
+
+          if behavior.arity == 4 || behavior.arity == -1
+            behavior
+          else
+            -> message, callstack, _, _ { behavior.call(message, callstack) }
+          end
+        end
     end
   end
 end

data/lib/active_support/deprecation/constant_accessor.rb

@@ -1,4 +1,4 @@
-require "active_support/inflector/methods"
+# frozen_string_literal: true
 
 module ActiveSupport
   class Deprecation
@@ -15,7 +15,7 @@ module ActiveSupport
     #
     #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
     #
-    #   (In a later update, the original implementation of `PLANETS` has been removed.)
+    #   # (In a later update, the original implementation of `PLANETS` has been removed.)
     #
     #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
     #   include ActiveSupport::Deprecation::DeprecatedConstantAccessor
@@ -27,6 +27,8 @@ module ActiveSupport
     #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
     module DeprecatedConstantAccessor
       def self.included(base)
+        require "active_support/inflector/methods"
+
         extension = Module.new do
           def const_missing(missing_const_name)
             if class_variable_defined?(:@@_deprecated_constants)

data/lib/active_support/deprecation/instance_delegator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/kernel/singleton_class"
 require "active_support/core_ext/module/delegation"