tokite 4.0.0 → 5.0.0

data/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/core_ext/symbol.rb

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

data/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/core_ext/time/calculations.rb

@@ -1,386 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/duration"
-require "active_support/core_ext/time/conversions"
-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
-
-  COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-
-  class << self
-    # Overriding case equality method so that it returns true for ActiveSupport::TimeWithZone instances
-    def ===(other)
-      super || (self == Time && other.is_a?(ActiveSupport::TimeWithZone))
-    end
-
-    # Returns the number of days in the given month.
-    # If no year is specified, it will use the current year.
-    def days_in_month(month, year = current.year)
-      if month == 2 && ::Date.gregorian_leap?(year)
-        29
-      else
-        COMMON_YEAR_DAYS_IN_MONTH[month]
-      end
-    end
-
-    # Returns the number of days in the given year.
-    # If no year is specified, it will use the current year.
-    def days_in_year(year = current.year)
-      days_in_month(2, year) + 337
-    end
-
-    # Returns <tt>Time.zone.now</tt> when <tt>Time.zone</tt> or <tt>config.time_zone</tt> are set, otherwise just returns <tt>Time.now</tt>.
-    def current
-      ::Time.zone ? ::Time.zone.now : ::Time.now
-    end
-
-    # Layers additional behavior on Time.at so that ActiveSupport::TimeWithZone and DateTime
-    # instances can be used when called with a single argument
-    def at_with_coercion(time_or_number, *args)
-      if args.empty?
-        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
-      else
-        at_without_coercion(time_or_number, *args)
-      end
-    end
-    ruby2_keywords :at_with_coercion
-    alias_method :at_without_coercion, :at
-    alias_method :at, :at_with_coercion
-
-    # Creates a +Time+ instance from an RFC 3339 string.
-    #
-    #   Time.rfc3339('1999-12-31T14:00:00-10:00') # => 2000-01-01 00:00:00 -1000
-    #
-    # If the time or offset components are missing then an +ArgumentError+ will be raised.
-    #
-    #   Time.rfc3339('1999-12-31') # => ArgumentError: invalid date
-    def rfc3339(str)
-      parts = Date._rfc3339(str)
-
-      raise ArgumentError, "invalid date" if parts.empty?
-
-      Time.new(
-        parts.fetch(:year),
-        parts.fetch(:mon),
-        parts.fetch(:mday),
-        parts.fetch(:hour),
-        parts.fetch(:min),
-        parts.fetch(:sec) + parts.fetch(:sec_fraction, 0),
-        parts.fetch(:offset)
-      )
-    end
-  end
-
-  # Returns the number of seconds since 00:00:00.
-  #
-  #   Time.new(2012, 8, 29,  0,  0,  0).seconds_since_midnight # => 0.0
-  #   Time.new(2012, 8, 29, 12, 34, 56).seconds_since_midnight # => 45296.0
-  #   Time.new(2012, 8, 29, 23, 59, 59).seconds_since_midnight # => 86399.0
-  def seconds_since_midnight
-    to_i - change(hour: 0).to_i + (usec / 1.0e+6)
-  end
-
-  # Returns the number of seconds until 23:59:59.
-  #
-  #   Time.new(2012, 8, 29,  0,  0,  0).seconds_until_end_of_day # => 86399
-  #   Time.new(2012, 8, 29, 12, 34, 56).seconds_until_end_of_day # => 41103
-  #   Time.new(2012, 8, 29, 23, 59, 59).seconds_until_end_of_day # => 0
-  def seconds_until_end_of_day
-    end_of_day.to_i - to_i
-  end
-
-  # Returns the fraction of a second as a +Rational+
-  #
-  #   Time.new(2012, 8, 29, 0, 0, 0.5).sec_fraction # => (1/2)
-  def sec_fraction
-    subsec
-  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
-  # 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>,
-  # <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_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]
-      new_usec = Rational(new_nsec, 1000)
-    else
-      new_usec = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
-    end
-
-    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.respond_to?(:utc_to_local)
-      new_time = ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, zone)
-
-      # Some versions of Ruby have a bug where Time.new with a zone object and
-      # fractional seconds will end up with a broken utc_offset.
-      # This is fixed in Ruby 3.3.1 and 3.2.4
-      unless new_time.utc_offset.integer?
-        new_time += 0
-      end
-
-      # When there are two occurrences of a nominal time due to DST ending,
-      # `Time.new` chooses the first chronological occurrence (the one with a
-      # larger UTC offset). However, for `change`, we want to choose the
-      # occurrence that matches this time's UTC offset.
-      #
-      # If the new time's UTC offset is larger than this time's UTC offset, the
-      # new time might be a first chronological occurrence. So we add the offset
-      # difference to fast-forward the new time, and check if the result has the
-      # desired UTC offset (i.e. is the second chronological occurrence).
-      offset_difference = new_time.utc_offset - utc_offset
-      if offset_difference > 0 && (new_time_2 = new_time + offset_difference).utc_offset == utc_offset
-        new_time_2
-      else
-        new_time
-      end
-    elsif zone
-      ::Time.local(new_sec, new_min, new_hour, new_day, new_month, new_year, nil, nil, isdst, nil)
-    else
-      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, utc_offset)
-    end
-  end
-
-  # Uses Date to provide precise Time calculations for years, months, and days
-  # according to the proleptic Gregorian calendar. The +options+ parameter
-  # takes a hash with any of these keys: <tt>:years</tt>, <tt>:months</tt>,
-  # <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>, <tt>:minutes</tt>,
-  # <tt>:seconds</tt>.
-  #
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(seconds: 1) # => 2015-08-01 14:35:01 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(minutes: 1) # => 2015-08-01 14:36:00 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(hours: 1)   # => 2015-08-01 15:35:00 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(days: 1)    # => 2015-08-02 14:35:00 -0700
-  #   Time.new(2015, 8, 1, 14, 35, 0).advance(weeks: 1)   # => 2015-08-08 14:35:00 -0700
-  #
-  # Just like Date#advance, increments are applied in order of time units from
-  # largest to smallest. This order can affect the result around the end of a
-  # month.
-  def advance(options)
-    unless options[:weeks].nil?
-      options[:weeks], partial_weeks = options[:weeks].divmod(1)
-      options[:days] = options.fetch(:days, 0) + 7 * partial_weeks
-    end
-
-    unless options[:days].nil?
-      options[:days], partial_days = options[:days].divmod(1)
-      options[:hours] = options.fetch(:hours, 0) + 24 * partial_days
-    end
-
-    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) +
-      options.fetch(:minutes, 0) * 60 +
-      options.fetch(:hours, 0) * 3600
-
-    if seconds_to_advance.zero?
-      time_advanced_by_date
-    else
-      time_advanced_by_date.since(seconds_to_advance)
-    end
-  end
-
-  # Returns a new Time representing the time a number of seconds ago, this is basically a wrapper around the Numeric extension
-  def ago(seconds)
-    since(-seconds)
-  end
-
-  # Returns a new Time representing the time a number of seconds since the instance time
-  def since(seconds)
-    self + seconds
-  rescue TypeError
-    result = to_datetime.since(seconds)
-    ActiveSupport.deprecator.warn(
-      "Passing an instance of #{seconds.class} to #{self.class}#since is deprecated. This behavior will raise " \
-      "a `TypeError` in Rails 8.1."
-    )
-    result
-  end
-  alias :in :since
-
-  # Returns a new Time representing the start of the day (0:00)
-  def beginning_of_day
-    change(hour: 0)
-  end
-  alias :midnight :beginning_of_day
-  alias :at_midnight :beginning_of_day
-  alias :at_beginning_of_day :beginning_of_day
-
-  # Returns a new Time representing the middle of the day (12:00)
-  def middle_of_day
-    change(hour: 12)
-  end
-  alias :midday :middle_of_day
-  alias :noon :middle_of_day
-  alias :at_midday :middle_of_day
-  alias :at_noon :middle_of_day
-  alias :at_middle_of_day :middle_of_day
-
-  # Returns a new Time representing the end of the day, 23:59:59.999999
-  def end_of_day
-    change(
-      hour: 23,
-      min: 59,
-      sec: 59,
-      usec: Rational(999999999, 1000)
-    )
-  end
-  alias :at_end_of_day :end_of_day
-
-  # Returns a new Time representing the start of the hour (x:00)
-  def beginning_of_hour
-    change(min: 0)
-  end
-  alias :at_beginning_of_hour :beginning_of_hour
-
-  # Returns a new Time representing the end of the hour, x:59:59.999999
-  def end_of_hour
-    change(
-      min: 59,
-      sec: 59,
-      usec: Rational(999999999, 1000)
-    )
-  end
-  alias :at_end_of_hour :end_of_hour
-
-  # Returns a new Time representing the start of the minute (x:xx:00)
-  def beginning_of_minute
-    change(sec: 0)
-  end
-  alias :at_beginning_of_minute :beginning_of_minute
-
-  # Returns a new Time representing the end of the minute, x:xx:59.999999
-  def end_of_minute
-    change(
-      sec: 59,
-      usec: Rational(999999999, 1000)
-    )
-  end
-  alias :at_end_of_minute :end_of_minute
-
-  def plus_with_duration(other) # :nodoc:
-    if ActiveSupport::Duration === other
-      other.since(self)
-    else
-      plus_without_duration(other)
-    end
-  end
-  alias_method :plus_without_duration, :+
-  alias_method :+, :plus_with_duration
-
-  def minus_with_duration(other) # :nodoc:
-    if ActiveSupport::Duration === other
-      other.until(self)
-    else
-      minus_without_duration(other)
-    end
-  end
-  alias_method :minus_without_duration, :-
-  alias_method :-, :minus_with_duration
-
-  # Time#- can also be used to determine the number of seconds between two Time instances.
-  # We're layering on additional behavior so that ActiveSupport::TimeWithZone instances
-  # are coerced into values that Time#- will recognize
-  def minus_with_coercion(other)
-    other = other.comparable_time if other.respond_to?(:comparable_time)
-    other.is_a?(DateTime) ? to_f - other.to_f : minus_without_coercion(other)
-  end
-  alias_method :minus_without_coercion, :-
-  alias_method :-, :minus_with_coercion # rubocop:disable Lint/DuplicateMethods
-
-  # Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances
-  # can be chronologically compared with a Time
-  def compare_with_coercion(other)
-    # we're avoiding Time#to_datetime and Time#to_time because they're expensive
-    if other.class == Time
-      compare_without_coercion(other)
-    elsif other.is_a?(Time)
-      # also avoid ActiveSupport::TimeWithZone#to_time before Rails 8.0
-      if other.respond_to?(:comparable_time)
-        compare_without_coercion(other.comparable_time)
-      else
-        compare_without_coercion(other.to_time)
-      end
-    else
-      to_datetime <=> other
-    end
-  end
-  alias_method :compare_without_coercion, :<=>
-  alias_method :<=>, :compare_with_coercion
-
-  # Layers additional behavior on Time#eql? so that ActiveSupport::TimeWithZone instances
-  # can be eql? to an equivalent Time
-  def eql_with_coercion(other)
-    # if other is an ActiveSupport::TimeWithZone, coerce a Time instance from it so we can do eql? comparison
-    other = other.comparable_time if other.respond_to?(:comparable_time)
-    eql_without_coercion(other)
-  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/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/core_ext/time/compatibility.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/date_and_time/compatibility"
-require "active_support/core_ext/module/redefine_method"
-
-class Time
-  include DateAndTime::Compatibility
-
-  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+.
-  def to_time
-    preserve_timezone ? self : getlocal
-  end
-
-  def preserve_timezone # :nodoc:
-    system_local_time? || super
-  end
-
-  private
-    def system_local_time?
-      if ::Time.equal?(self.class)
-        zone = self.zone
-        String === zone &&
-          (zone != "UTC" || active_support_local_zone == "UTC")
-      end
-    end
-
-    @@active_support_local_tz = nil
-
-    def active_support_local_zone
-      @@active_support_local_zone = nil if @@active_support_local_tz != ENV["TZ"]
-      @@active_support_local_zone ||=
-        begin
-          @@active_support_local_tz = ENV["TZ"]
-          Time.new.zone
-        end
-    end
-end

data/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/core_ext/time.rb

@@ -1,7 +0,0 @@
-# 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/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/core_ext.rb

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

data/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/current_attributes/test_helper.rb

@@ -1,13 +0,0 @@
-# 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/vendor/bundle/ruby/3.4.0/gems/activesupport-8.0.4/lib/active_support/current_attributes.rb

@@ -1,240 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/callbacks"
-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 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
-          IsolatedExecutionState[: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_accessor :attributes
-
-    def initialize
-      @attributes = resolve_defaults
-    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