activesupport 4.2.11.1 → 5.2.4

data/lib/active_support/core_ext/time.rb

@@ -1,6 +1,7 @@
-require 'active_support/core_ext/time/acts_like'
-require 'active_support/core_ext/time/calculations'
-require 'active_support/core_ext/time/compatibility'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/time/marshal'
-require 'active_support/core_ext/time/zones'
+# 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"
+require "active_support/core_ext/time/conversions"
+require "active_support/core_ext/time/zones"

data/lib/active_support/core_ext/uri.rb

@@ -1,18 +1,16 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-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
-
-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) { [$&[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

@@ -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