activesupport 4.2.11.1 → 6.1.7.3

data/lib/active_support/current_attributes.rb

@@ -0,0 +1,210 @@
+# 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
+  # 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[current_instances_key] ||= 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 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
+
+      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 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.
+          #
+          # By letting #delegate handle it, we avoid an enclosure that'll capture args.
+          singleton_class.delegate name, to: :instance
+
+          send(name, *args, &block)
+        end
+        ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    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.index_with { |key| public_send(key) }
+      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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "active_support/concurrency/share_lock"
+
+module ActiveSupport #:nodoc:
+  module Dependencies #:nodoc:
+    class Interlock
+      def initialize # :nodoc:
+        @lock = ActiveSupport::Concurrency::ShareLock.new
+      end
+
+      def loading
+        @lock.exclusive(purpose: :load, compatible: [:load], after_compatible: [:load]) do
+          yield
+        end
+      end
+
+      def unloading
+        @lock.exclusive(purpose: :unload, compatible: [:load, :unload], after_compatible: [:load, :unload]) do
+          yield
+        end
+      end
+
+      def start_unloading
+        @lock.start_exclusive(purpose: :unload, compatible: [:load, :unload])
+      end
+
+      def done_unloading
+        @lock.stop_exclusive(compatible: [:load, :unload])
+      end
+
+      def start_running
+        @lock.start_sharing
+      end
+
+      def done_running
+        @lock.stop_sharing
+      end
+
+      def running
+        @lock.sharing do
+          yield
+        end
+      end
+
+      def permit_concurrent_loads
+        @lock.yield_shares(compatible: [:load]) do
+          yield
+        end
+      end
+
+      def raw_state(&block) # :nodoc:
+        @lock.raw_state(&block)
+      end
+    end
+  end
+end

data/lib/active_support/dependencies/zeitwerk_integration.rb

@@ -0,0 +1,120 @@
+# 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
+
+            # Order matters.
+            Rails.autoloaders.once.setup
+            Rails.autoloaders.main.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