activesupport 1.2.4 → 8.1.2

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

@@ -0,0 +1,97 @@
+# 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"
+
+class Time
+  include DateAndTime::Zones
+  class << self
+    attr_accessor :zone_default
+
+    # Returns the TimeZone for the current request, if this has been set (via Time.zone=).
+    # If <tt>Time.zone</tt> has not been set for the current request, returns the TimeZone specified in <tt>config.time_zone</tt>.
+    def zone
+      ::ActiveSupport::IsolatedExecutionState[:time_zone] || zone_default
+    end
+
+    # Sets <tt>Time.zone</tt> to a TimeZone object for the current request/thread.
+    #
+    # This method accepts any of the following:
+    #
+    # * A \Rails TimeZone object.
+    # * An identifier for a \Rails TimeZone object (e.g., "Eastern \Time (US & Canada)", <tt>-5.hours</tt>).
+    # * A +TZInfo::Timezone+ object.
+    # * An identifier for a +TZInfo::Timezone+ object (e.g., "America/New_York").
+    #
+    # Here's an example of how you might set <tt>Time.zone</tt> on a per request basis and reset it when the request is done.
+    # <tt>current_user.time_zone</tt> just needs to return a string identifying the user's preferred time zone:
+    #
+    #   class ApplicationController < ActionController::Base
+    #     around_action :set_time_zone
+    #
+    #     def set_time_zone
+    #       if logged_in?
+    #         Time.use_zone(current_user.time_zone) { yield }
+    #       else
+    #         yield
+    #       end
+    #     end
+    #   end
+    def zone=(time_zone)
+      ::ActiveSupport::IsolatedExecutionState[:time_zone] = find_zone!(time_zone)
+    end
+
+    # Allows override of <tt>Time.zone</tt> locally inside supplied block;
+    # resets <tt>Time.zone</tt> to existing value when done.
+    #
+    #   class ApplicationController < ActionController::Base
+    #     around_action :set_time_zone
+    #
+    #     private
+    #       def set_time_zone
+    #         Time.use_zone(current_user.timezone) { yield }
+    #       end
+    #   end
+    #
+    # NOTE: This won't affect any ActiveSupport::TimeWithZone
+    # 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
+        old_zone, ::Time.zone = ::Time.zone, new_zone
+        yield
+      ensure
+        ::Time.zone = old_zone
+      end
+    end
+
+    # Returns a TimeZone instance matching the time zone provided.
+    # Accepts the time zone in any format supported by <tt>Time.zone=</tt>.
+    # Raises an +ArgumentError+ for invalid time zones.
+    #
+    #   Time.find_zone! "America/New_York" # => #<ActiveSupport::TimeZone @name="America/New_York" ...>
+    #   Time.find_zone! "EST"              # => #<ActiveSupport::TimeZone @name="EST" ...>
+    #   Time.find_zone! -5.hours           # => #<ActiveSupport::TimeZone @name="Bogota" ...>
+    #   Time.find_zone! nil                # => nil
+    #   Time.find_zone! false              # => false
+    #   Time.find_zone! "NOT-A-TIMEZONE"   # => ArgumentError: Invalid Timezone: NOT-A-TIMEZONE
+    def find_zone!(time_zone)
+      return time_zone unless time_zone
+
+      ActiveSupport::TimeZone[time_zone] || raise(ArgumentError, "Invalid Timezone: #{time_zone}")
+    end
+
+    # Returns a TimeZone instance matching the time zone provided.
+    # Accepts the time zone in any format supported by <tt>Time.zone=</tt>.
+    # Returns +nil+ for invalid time zones.
+    #
+    #   Time.find_zone "America/New_York" # => #<ActiveSupport::TimeZone @name="America/New_York" ...>
+    #   Time.find_zone "NOT-A-TIMEZONE"   # => nil
+    def find_zone(time_zone)
+      find_zone!(time_zone) rescue nil
+    end
+  end
+end

data/lib/active_support/core_ext/time.rb

@@ -1,7 +1,7 @@
-require File.dirname(__FILE__) + '/time/calculations'
-require File.dirname(__FILE__) + '/time/conversions'
+# frozen_string_literal: true
 
-class Time#:nodoc:
-  include ActiveSupport::CoreExtensions::Time::Calculations
-  include ActiveSupport::CoreExtensions::Time::Conversions
-end
+require_relative "time/acts_like"
+require_relative "time/calculations"
+require_relative "time/compatibility"
+require_relative "time/conversions"
+require_relative "time/zones"

data/lib/active_support/core_ext.rb

@@ -1 +1,5 @@
-Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].each { |file| require(file) }
+# frozen_string_literal: true
+
+(Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort - [File.expand_path("core_ext/benchmark.rb", __dir__)]).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.clear_all
+    super
+  end
+
+  def after_teardown
+    super
+    ActiveSupport::CurrentAttributes.clear_all
+  end
+end

data/lib/active_support/current_attributes.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+require "active_support/execution_context"
+require "active_support/core_ext/object/with"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/module/delegation"
+
+module ActiveSupport
+  # = Current Attributes
+  #
+  # 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
+
+    INVALID_ATTRIBUTE_NAMES = [:set, :reset, :resets, :instance, :before_reset, :after_reset, :reset_all, :clear_all] # :nodoc:
+
+    NOT_SET = Object.new.freeze # :nodoc:
+
+    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.
+      #
+      # ==== Options
+      #
+      # * <tt>:default</tt> - The default value for the attributes. If the value
+      #   is a proc or lambda, it will be called whenever an instance is
+      #   constructed. Otherwise, the value will be duplicated with +#dup+.
+      #   Default values are re-assigned when the attributes are reset.
+      def attribute(*names, default: NOT_SET)
+        invalid_attribute_names = names.map(&:to_sym) & INVALID_ATTRIBUTE_NAMES
+        if invalid_attribute_names.any?
+          raise ArgumentError, "Restricted attribute names: #{invalid_attribute_names.join(", ")}"
+        end
+
+        Delegation.generate(singleton_class, names, to: :instance, nilable: false, signature: "")
+        Delegation.generate(singleton_class, names.map { |n| "#{n}=" }, to: :instance, nilable: false, signature: "value")
+
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
+          names.each do |name|
+            owner.define_cached_method(name, namespace: :current_attributes) do |batch|
+              batch <<
+                "def #{name}" <<
+                "@attributes[:#{name}]" <<
+                "end"
+            end
+            owner.define_cached_method("#{name}=", namespace: :current_attributes) do |batch|
+              batch <<
+                "def #{name}=(value)" <<
+                "@attributes[:#{name}] = value" <<
+                "end"
+            end
+          end
+        end
+
+        self.defaults = defaults.merge(names.index_with { default })
+      end
+
+      # Calls this callback before #reset is called on the instance. Used for resetting external collaborators that depend on current values.
+      def before_reset(*methods, &block)
+        set_callback :reset, :before, *methods, &block
+      end
+
+      # Calls this callback after #reset is called on the instance. Used for resetting external collaborators, like Time.zone.
+      def resets(*methods, &block)
+        set_callback :reset, :after, *methods, &block
+      end
+      alias_method :after_reset, :resets
+
+      delegate :set, :reset, to: :instance
+
+      def clear_all # :nodoc:
+        if instances = current_instances
+          instances.values.each(&:reset)
+          instances.clear
+        end
+      end
+
+      private
+        def generated_attribute_methods
+          @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
+        end
+
+        def current_instances
+          ExecutionContext.current_attributes_instances
+        end
+
+        def current_instances_key
+          @current_instances_key ||= name.to_sym
+        end
+
+        def method_missing(name, ...)
+          instance.public_send(name, ...)
+        end
+
+        def respond_to_missing?(name, _)
+          instance.respond_to?(name) || super
+        end
+
+        def method_added(name)
+          super
+
+          # We try to generate instance delegators early to not rely on method_missing.
+          return if name == :initialize
+
+          # If the added method isn't public, we don't delegate it.
+          return unless public_method_defined?(name)
+
+          # If we already have a class method by that name, we don't override it.
+          return if singleton_class.method_defined?(name) || singleton_class.private_method_defined?(name)
+
+          Delegation.generate(singleton_class, [name], to: :instance, as: self, nilable: false)
+        end
+    end
+
+    class_attribute :defaults, instance_writer: false, default: {}.freeze
+
+    attr_writer :attributes
+
+    def initialize
+      @attributes = resolve_defaults
+    end
+
+    def attributes
+      @attributes.dup
+    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(attributes, &block)
+      with(**attributes, &block)
+    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 = resolve_defaults
+      end
+    end
+
+    private
+      def resolve_defaults
+        defaults.each_with_object({}) do |(key, value), result|
+          if value != NOT_SET
+            result[key] = Proc === value ? value.call : value.dup
+          end
+        end
+      end
+  end
+end

data/lib/active_support/deep_mergeable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Provides +deep_merge+ and +deep_merge!+ methods. Expects the including class
+  # to provide a <tt>merge!(other, &block)</tt> method.
+  module DeepMergeable # :nodoc:
+    # Returns a new instance with the values from +other+ merged recursively.
+    #
+    #   class Hash
+    #     include ActiveSupport::DeepMergeable
+    #   end
+    #
+    #   hash_1 = { a: true, b: { c: [1, 2, 3] } }
+    #   hash_2 = { a: false, b: { x: [3, 4, 5] } }
+    #
+    #   hash_1.deep_merge(hash_2)
+    #   # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+    #
+    # A block can be provided to merge non-<tt>DeepMergeable</tt> values:
+    #
+    #   hash_1 = { a: 100, b: 200, c: { c1: 100 } }
+    #   hash_2 = { b: 250, c: { c1: 200 } }
+    #
+    #   hash_1.deep_merge(hash_2) do |key, this_val, other_val|
+    #     this_val + other_val
+    #   end
+    #   # => { a: 100, b: 450, c: { c1: 300 } }
+    #
+    def deep_merge(other, &block)
+      dup.deep_merge!(other, &block)
+    end
+
+    # Same as #deep_merge, but modifies +self+.
+    def deep_merge!(other, &block)
+      merge!(other) do |key, this_val, other_val|
+        if this_val.is_a?(DeepMergeable) && this_val.deep_merge?(other_val)
+          this_val.deep_merge(other_val, &block)
+        elsif block_given?
+          block.call(key, this_val, other_val)
+        else
+          other_val
+        end
+      end
+    end
+
+    # Returns true if +other+ can be deep merged into +self+. Classes may
+    # override this method to restrict or expand the domain of deep mergeable
+    # values. Defaults to checking that +other+ is of type +self.class+.
+    def deep_merge?(other)
+      other.is_a?(self.class)
+    end
+  end
+end

data/lib/active_support/delegation.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
+  # option is not used.
+  class DelegationError < NoMethodError
+    class << self
+      def nil_target(method_name, target) # :nodoc:
+        new("#{method_name} delegated to #{target}, but #{target} is nil")
+      end
+    end
+  end
+
+  module Delegation # :nodoc:
+    RUBY_RESERVED_KEYWORDS = %w(__ENCODING__ __LINE__ __FILE__ alias and BEGIN begin break
+    case class def defined? do else elsif END end ensure false for if in module next nil
+    not or redo rescue retry return self super then true undef unless until when while yield)
+    RESERVED_METHOD_NAMES = (RUBY_RESERVED_KEYWORDS + %w(_ arg args block)).to_set.freeze
+
+    class << self
+      def generate(owner, methods, location: nil, to: nil, prefix: nil, allow_nil: nil, nilable: true, private: nil, as: nil, signature: nil)
+        unless to
+          raise ArgumentError, "Delegation needs a target. Supply a keyword argument 'to' (e.g. delegate :hello, to: :greeter)."
+        end
+
+        if prefix == true && /^[^a-z_]/.match?(to)
+          raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+        end
+
+        method_prefix = \
+          if prefix
+            "#{prefix == true ? to : prefix}_"
+          else
+            ""
+          end
+
+        location ||= caller_locations(1, 1).first
+        file, line = location.path, location.lineno
+
+        receiver = if to.is_a?(Module)
+          if to.name.nil?
+            raise ArgumentError, "Can't delegate to anonymous class or module: #{to}"
+          end
+
+          unless Inflector.safe_constantize(to.name).equal?(to)
+            raise ArgumentError, "Can't delegate to detached class or module: #{to.name}"
+          end
+
+          "::#{to.name}"
+        else
+          to.to_s
+        end
+        receiver = "self.#{receiver}" if RESERVED_METHOD_NAMES.include?(receiver)
+
+        explicit_receiver = false
+        receiver_class = if as
+          explicit_receiver = true
+          as
+        elsif to.is_a?(Module)
+          to.singleton_class
+        elsif receiver == "self.class"
+          nilable = false # self.class can't possibly be nil
+          owner.singleton_class
+        end
+
+        method_def = []
+        method_names = []
+
+        method_def << "self.private" if private
+
+        methods.each do |method|
+          method_name = prefix ? "#{method_prefix}#{method}" : method
+          method_names << method_name.to_sym
+
+          # Attribute writer methods only accept one argument. Makes sure []=
+          # methods still accept two arguments.
+          definition = \
+            if signature
+              signature
+            elsif /[^\]]=\z/.match?(method)
+              "arg"
+            else
+              method_object = if receiver_class
+                begin
+                  receiver_class.public_instance_method(method)
+                rescue NameError
+                  raise if explicit_receiver
+                  # Do nothing. Fall back to `"..."`
+                end
+              end
+
+              if method_object
+                parameters = method_object.parameters
+
+                if parameters.map(&:first).intersect?([:opt, :rest, :keyreq, :key, :keyrest])
+                  "..."
+                else
+                  defn = parameters.filter_map { |type, arg| arg if type == :req }
+                  defn << "&"
+                  defn.join(", ")
+                end
+              else
+                "..."
+              end
+            end
+
+          # The following generated method calls the target exactly once, storing
+          # the returned value in a dummy variable.
+          #
+          # Reason is twofold: On one hand doing less calls is in general better.
+          # On the other hand it could be that the target has side-effects,
+          # whereas conceptually, from the user point of view, the delegator should
+          # be doing one call.
+          if nilable == false
+            method_def <<
+              "def #{method_name}(#{definition})" <<
+              "  (#{receiver}).#{method}(#{definition})" <<
+              "end"
+          elsif allow_nil
+            method = method.to_s
+
+            method_def <<
+              "def #{method_name}(#{definition})" <<
+              "  _ = #{receiver}" <<
+              "  if !_.nil? || nil.respond_to?(:#{method})" <<
+              "    _.#{method}(#{definition})" <<
+              "  end" <<
+              "end"
+          else
+            method = method.to_s
+            method_name = method_name.to_s
+
+            method_def <<
+              "def #{method_name}(#{definition})" <<
+              "  _ = #{receiver}" <<
+              "  _.#{method}(#{definition})" <<
+              "rescue ::NoMethodError => e" <<
+              "  if _.nil? && e.name == :#{method}" <<
+              "    ::Kernel.raise ::ActiveSupport::DelegationError.nil_target(:#{method_name}, :'#{receiver}')" <<
+              "  else" <<
+              "    ::Kernel.raise" <<
+              "  end" <<
+              "end"
+          end
+        end
+        owner.module_eval(method_def.join(";"), file, line)
+        method_names
+      end
+
+      def generate_method_missing(owner, target, allow_nil: nil)
+        target = target.to_s
+        target = "self.#{target}" if RESERVED_METHOD_NAMES.include?(target) || target == "__target"
+
+        nil_behavior = if allow_nil
+          "nil"
+        else
+          "::Kernel.raise ::ActiveSupport::DelegationError.nil_target(method, :'#{target}')"
+        end
+
+        owner.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def respond_to_missing?(name, include_private = false)
+            # It may look like an oversight, but we deliberately do not pass
+            # +include_private+, because they do not get delegated.
+
+            return false if name == :marshal_dump || name == :_dump
+            #{target}.respond_to?(name) || super
+          end
+
+          def method_missing(method, ...)
+            __target = #{target}
+            if __target.nil? && !nil.respond_to?(method)
+              #{nil_behavior}
+            elsif __target.respond_to?(method)
+              __target.public_send(method, ...)
+            else
+              super
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/active_support/dependencies/autoload.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "active_support/inflector/methods"
+
+module ActiveSupport
+  # = Active Support \Autoload
+  #
+  # Autoload and eager load conveniences for your library.
+  #
+  # This module allows you to define autoloads based on
+  # \Rails conventions (i.e. no need to define the path
+  # it is automatically guessed based on the filename)
+  # and also define a set of constants that needs to be
+  # eager loaded:
+  #
+  #   module MyLib
+  #     extend ActiveSupport::Autoload
+  #
+  #     autoload :Model
+  #
+  #     eager_autoload do
+  #       autoload :Cache
+  #     end
+  #   end
+  #
+  # Then your library can be eager loaded by simply calling:
+  #
+  #   MyLib.eager_load!
+  module Autoload
+    def autoload(const_name, path = @_at_path)
+      unless path
+        full = [name, @_under_path, const_name.to_s].compact.join("::")
+        path = Inflector.underscore(full)
+      end
+
+      if @_eager_autoload
+        @_eagerloaded_constants ||= []
+        @_eagerloaded_constants << const_name
+      end
+
+      super const_name, path
+    end
+
+    def autoload_under(path)
+      @_under_path, old_path = path, @_under_path
+      yield
+    ensure
+      @_under_path = old_path
+    end
+
+    def autoload_at(path)
+      @_at_path, old_path = path, @_at_path
+      yield
+    ensure
+      @_at_path = old_path
+    end
+
+    def eager_autoload
+      old_eager, @_eager_autoload = @_eager_autoload, true
+      yield
+    ensure
+      @_eager_autoload = old_eager
+    end
+
+    def eager_load!
+      if @_eagerloaded_constants
+        @_eagerloaded_constants.each { |const_name| const_get(const_name) }
+        @_eagerloaded_constants = nil
+      end
+    end
+  end
+end