activesupport 6.0.4 → 6.1.4

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

@@ -47,9 +47,9 @@ class String
   #   iso_str.is_utf8?   # => false
   def is_utf8?
     case encoding
-    when Encoding::UTF_8
+    when Encoding::UTF_8, Encoding::US_ASCII
       valid_encoding?
-    when Encoding::ASCII_8BIT, Encoding::US_ASCII
+    when Encoding::ASCII_8BIT
       dup.force_encoding(Encoding::UTF_8).valid_encoding?
     else
       false

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "erb"
-require "active_support/core_ext/kernel/singleton_class"
 require "active_support/core_ext/module/redefine_method"
 require "active_support/multibyte/unicode"
 
@@ -85,7 +84,7 @@ class ERB
     # use inside HTML attributes.
     #
     # If your JSON is being used downstream for insertion into the DOM, be aware of
-    # whether or not it is being inserted via +html()+. Most jQuery plugins do this.
+    # whether or not it is being inserted via <tt>html()</tt>. Most jQuery plugins do this.
     # If that is the case, be sure to +html_escape+ or +sanitize+ any user-generated
     # content returned by your JSON.
     #
@@ -202,7 +201,7 @@ module ActiveSupport #:nodoc:
     end
 
     def []=(*args)
-      if args.count == 3
+      if args.length == 3
         super(args[0], args[1], html_escape_interpolated_argument(args[2]))
       else
         super(args[0], html_escape_interpolated_argument(args[1]))
@@ -223,7 +222,7 @@ module ActiveSupport #:nodoc:
     def %(args)
       case args
       when Hash
-        escaped_args = Hash[args.map { |k, arg| [k, html_escape_interpolated_argument(arg)] }]
+        escaped_args = args.transform_values { |arg| html_escape_interpolated_argument(arg) }
       else
         escaped_args = Array(args).map { |arg| html_escape_interpolated_argument(arg) }
       end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 class String
-  alias_method :starts_with?, :start_with?
-  alias_method :ends_with?, :end_with?
+  alias :starts_with? :start_with?
+  alias :ends_with? :end_with?
 end

data/lib/active_support/core_ext/symbol/starts_ends_with.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Symbol
+  def start_with?(*prefixes)
+    to_s.start_with?(*prefixes)
+  end unless method_defined?(:start_with?)
+
+  def end_with?(*suffixes)
+    to_s.end_with?(*suffixes)
+  end unless method_defined?(:end_with?)
+
+  alias :starts_with? :start_with?
+  alias :ends_with? :end_with?
+end

data/lib/active_support/core_ext/symbol.rb

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

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

@@ -6,6 +6,7 @@ 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
@@ -55,6 +56,7 @@ class Time
         at_without_coercion(time_or_number)
       end
     end
+    ruby2_keywords(:at_with_coercion) if respond_to?(:ruby2_keywords, true)
     alias_method :at_without_coercion, :at
     alias_method :at, :at_with_coercion
 
@@ -107,6 +109,21 @@ class Time
     subsec
   end
 
+  unless Time.method_defined?(:floor)
+    def floor(precision = 0)
+      change(nsec: 0) + subsec.floor(precision)
+    end
+  end
+
+  # Restricted Ruby version due to a bug in `Time#ceil`
+  # See https://bugs.ruby-lang.org/issues/17025 for more details
+  if RUBY_VERSION <= "2.8"
+    remove_possible_method :ceil
+    def ceil(precision = 0)
+      change(nsec: 0) + subsec.ceil(precision)
+    end
+  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

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

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require "time"
 require "active_support/inflector/methods"
 require "active_support/values/time_zone"
 
 class Time
   DATE_FORMATS = {
     db: "%Y-%m-%d %H:%M:%S",
+    inspect: "%Y-%m-%d %H:%M:%S.%9N %z",
     number: "%Y%m%d%H%M%S",
     nsec: "%Y%m%d%H%M%S%9N",
     usec: "%Y%m%d%H%M%S%6N",

data/lib/active_support/core_ext/uri.rb

@@ -19,7 +19,11 @@ end
 module URI
   class << self
     def parser
-      @parser ||= URI::Parser.new
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+        URI.parser is deprecated and will be removed in Rails 6.2.
+        Use `URI::DEFAULT_PARSER` instead.
+      MSG
+      URI::DEFAULT_PARSER
     end
   end
 end

data/lib/active_support/core_ext.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).each do |path|
+Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort.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.reset_all
+    super
+  end
+
+  def after_teardown
+    super
+    ActiveSupport::CurrentAttributes.reset_all
+  end
+end

data/lib/active_support/current_attributes.rb

@@ -1,6 +1,8 @@
 # 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
@@ -91,7 +93,7 @@ module ActiveSupport
     class << self
       # Returns singleton instance for this class in this thread. If none exists, one is created.
       def instance
-        current_instances[name] ||= new
+        current_instances[current_instances_key] ||= new
       end
 
       # Declares one or more attributes that will be given both class and instance accessor methods.
@@ -150,6 +152,10 @@ module ActiveSupport
           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.
           #
@@ -197,7 +203,7 @@ module ActiveSupport
       end
 
       def compute_attributes(keys)
-        keys.collect { |key| [ key, public_send(key) ] }.to_h
+        keys.index_with { |key| public_send(key) }
       end
   end
 end

data/lib/active_support/dependencies.rb

@@ -12,7 +12,6 @@ require "active_support/core_ext/object/blank"
 require "active_support/core_ext/kernel/reporting"
 require "active_support/core_ext/load_error"
 require "active_support/core_ext/name_error"
-require "active_support/core_ext/string/starts_ends_with"
 require "active_support/dependencies/interlock"
 require "active_support/inflector"
 
@@ -262,15 +261,24 @@ module ActiveSupport #:nodoc:
 
       # :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
+      # <b>Warning:</b> This method is obsolete in +:zeitwerk+ mode. In
+      # +:zeitwerk+ mode semantics match Ruby's and you do not need to be
+      # defensive with load order. Just refer to classes and modules normally.
+      # If the constant name is dynamic, camelize if needed, and constantize.
+      #
+      # In +:classic+ mode, interprets a file using +mechanism+ and marks its
+      # defined constants as autoloaded. +file_name+ can be either a string or
       # respond to <tt>to_path</tt>.
       #
-      # Use this method in code that absolutely needs a certain constant to be
-      # defined at that point. A typical use case is to make constant name
-      # resolution deterministic for constants with the same relative name in
-      # different namespaces whose evaluation would depend on load order
-      # otherwise.
+      # In +:classic+ mode, use this method in code that absolutely needs a
+      # certain constant to be defined at that point. A typical use case is to
+      # make constant name resolution deterministic for constants with the same
+      # relative name in different namespaces whose evaluation would depend on
+      # load order otherwise.
+      #
+      # Engines that do not control the mode in which their parent application
+      # runs should call +require_dependency+ where needed in case the runtime
+      # mode is +:classic+.
       def require_dependency(file_name, message = "No such file to load -- %s.rb")
         file_name = file_name.to_path if file_name.respond_to?(:to_path)
         unless file_name.is_a?(String)
@@ -458,7 +466,7 @@ module ActiveSupport #:nodoc:
 
     # Search for a file in autoload_paths matching the provided suffix.
     def search_for_file(path_suffix)
-      path_suffix += ".rb" unless path_suffix.ends_with?(".rb")
+      path_suffix += ".rb" unless path_suffix.end_with?(".rb")
 
       autoload_paths.each do |root|
         path = File.join(root, path_suffix)
@@ -478,9 +486,9 @@ module ActiveSupport #:nodoc:
     end
 
     def load_once_path?(path)
-      # to_s works around a ruby issue where String#starts_with?(Pathname)
+      # to_s works around a ruby issue where String#start_with?(Pathname)
       # will raise a TypeError: no implicit conversion of Pathname into String
-      autoload_once_paths.any? { |base| path.starts_with? base.to_s }
+      autoload_once_paths.any? { |base| path.start_with?(base.to_s) }
     end
 
     # Attempt to autoload the provided module name by searching for a directory
@@ -530,7 +538,8 @@ module ActiveSupport #:nodoc:
     # it is not possible to load the constant into from_mod, try its parent
     # module using +const_missing+.
     def load_missing_constant(from_mod, const_name)
-      unless qualified_const_defined?(from_mod.name) && Inflector.constantize(from_mod.name).equal?(from_mod)
+      from_mod_name = real_mod_name(from_mod)
+      unless qualified_const_defined?(from_mod_name) && Inflector.constantize(from_mod_name).equal?(from_mod)
         raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
       end
 
@@ -541,7 +550,7 @@ module ActiveSupport #:nodoc:
 
       if file_path
         expanded = File.expand_path(file_path)
-        expanded.sub!(/\.rb\z/, "")
+        expanded.delete_suffix!(".rb")
 
         if loading.include?(expanded)
           raise "Circular dependency detected while autoloading constant #{qualified_name}"
@@ -589,8 +598,8 @@ module ActiveSupport #:nodoc:
         end
       end
 
-      name_error = NameError.new("uninitialized constant #{qualified_name}", const_name)
-      name_error.set_backtrace(caller.reject { |l| l.starts_with? __FILE__ })
+      name_error = uninitialized_constant(qualified_name, const_name, receiver: from_mod)
+      name_error.set_backtrace(caller.reject { |l| l.start_with? __FILE__ })
       raise name_error
     end
 
@@ -719,7 +728,7 @@ module ActiveSupport #:nodoc:
     # A module, class, symbol, or string may be provided.
     def to_constant_name(desc) #:nodoc:
       case desc
-      when String then desc.sub(/^::/, "")
+      when String then desc.delete_prefix("::")
       when Symbol then desc.to_s
       when Module
         real_mod_name(desc) ||
@@ -730,7 +739,7 @@ module ActiveSupport #:nodoc:
 
     def remove_constant(const) #:nodoc:
       # Normalize ::Foo, ::Object::Foo, Object::Foo, Object::Object::Foo, etc. as Foo.
-      normalized = const.to_s.sub(/\A::/, "")
+      normalized = const.to_s.delete_prefix("::")
       normalized.sub!(/\A(Object::)+/, "")
 
       constants = normalized.split("::")
@@ -740,7 +749,7 @@ module ActiveSupport #:nodoc:
       file_path = search_for_file(const.underscore)
       if file_path
         expanded = File.expand_path(file_path)
-        expanded.sub!(/\.rb\z/, "")
+        expanded.delete_suffix!(".rb")
         loaded.delete(expanded)
       end
 
@@ -798,6 +807,16 @@ module ActiveSupport #:nodoc:
     end
 
     private
+      if RUBY_VERSION < "2.6"
+        def uninitialized_constant(qualified_name, const_name, receiver:)
+          NameError.new("uninitialized constant #{qualified_name}", const_name)
+        end
+      else
+        def uninitialized_constant(qualified_name, const_name, receiver:)
+          NameError.new("uninitialized constant #{qualified_name}", const_name, receiver: receiver)
+        end
+      end
+
       # Returns the original name of a class or module even if `name` has been
       # overridden.
       def real_mod_name(mod)

data/lib/active_support/deprecation/behaviors.rb

@@ -51,7 +51,7 @@ module ActiveSupport
     # constant. Available behaviors are:
     #
     # [+raise+]   Raise <tt>ActiveSupport::DeprecationException</tt>.
-    # [+stderr+]  Log all deprecation warnings to +$stderr+.
+    # [+stderr+]  Log all deprecation warnings to <tt>$stderr</tt>.
     # [+log+]     Log all deprecation warnings to +Rails.logger+.
     # [+notify+]  Use +ActiveSupport::Notifications+ to notify +deprecation.rails+.
     # [+silence+] Do nothing.
@@ -67,13 +67,18 @@ module ActiveSupport
         @behavior ||= [DEFAULT_BEHAVIORS[:stderr]]
       end
 
+      # Returns the current behavior for disallowed deprecations or if one isn't set, defaults to +:raise+.
+      def disallowed_behavior
+        @disallowed_behavior ||= [DEFAULT_BEHAVIORS[:raise]]
+      end
+
       # Sets the behavior to the specified value. Can be a single value, array,
       # or an object that responds to +call+.
       #
       # Available behaviors:
       #
       # [+raise+]   Raise <tt>ActiveSupport::DeprecationException</tt>.
-      # [+stderr+]  Log all deprecation warnings to +$stderr+.
+      # [+stderr+]  Log all deprecation warnings to <tt>$stderr</tt>.
       # [+log+]     Log all deprecation warnings to +Rails.logger+.
       # [+notify+]  Use +ActiveSupport::Notifications+ to notify +deprecation.rails+.
       # [+silence+] Do nothing.
@@ -92,6 +97,14 @@ module ActiveSupport
         @behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || arity_coerce(b) }
       end
 
+      # Sets the behavior for disallowed deprecations (those configured by
+      # ActiveSupport::Deprecation.disallowed_warnings=) to the specified
+      # value. As with +behavior=+, this can be a single value, array, or an
+      # object that responds to +call+.
+      def disallowed_behavior=(behavior)
+        @disallowed_behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || arity_coerce(b) }
+      end
+
       private
         def arity_coerce(behavior)
           unless behavior.respond_to?(:call)

data/lib/active_support/deprecation/disallowed.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class Deprecation
+    module Disallowed
+      # Sets the criteria used to identify deprecation messages which should be
+      # disallowed. Can be an array containing strings, symbols, or regular
+      # expressions. (Symbols are treated as strings). These are compared against
+      # the text of the generated deprecation warning.
+      #
+      # Additionally the scalar symbol +:all+ may be used to treat all
+      # deprecations as disallowed.
+      #
+      # Deprecations matching a substring or regular expression will be handled
+      # using the configured +ActiveSupport::Deprecation.disallowed_behavior+
+      # rather than +ActiveSupport::Deprecation.behavior+
+      attr_writer :disallowed_warnings
+
+      # Returns the configured criteria used to identify deprecation messages
+      # which should be treated as disallowed.
+      def disallowed_warnings
+        @disallowed_warnings ||= []
+      end
+
+      private
+        def deprecation_disallowed?(message)
+          disallowed = ActiveSupport::Deprecation.disallowed_warnings
+          return false if explicitly_allowed?(message)
+          return true if disallowed == :all
+          disallowed.any? do |rule|
+            case rule
+            when String, Symbol
+              message.include?(rule.to_s)
+            when Regexp
+              rule.match?(message)
+            end
+          end
+        end
+
+        def explicitly_allowed?(message)
+          allowances = @explicitly_allowed_warnings.value
+          return false unless allowances
+          return true if allowances == :all
+          allowances = [allowances] unless allowances.kind_of?(Array)
+          allowances.any? do |rule|
+            case rule
+            when String, Symbol
+              message.include?(rule.to_s)
+            when Regexp
+              rule.match?(message)
+            end
+          end
+        end
+    end
+  end
+end

data/lib/active_support/deprecation/instance_delegator.rb

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

data/lib/active_support/deprecation/method_wrappers.rb

@@ -56,11 +56,12 @@ module ActiveSupport
         mod = nil
 
         method_names.each do |method_name|
+          message = options[method_name]
           if target_module.method_defined?(method_name) || target_module.private_method_defined?(method_name)
             method = target_module.instance_method(method_name)
             target_module.module_eval do
               redefine_method(method_name) do |*args, &block|
-                deprecator.deprecation_warning(method_name, options[method_name])
+                deprecator.deprecation_warning(method_name, message)
                 method.bind(self).call(*args, &block)
               end
               ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
@@ -69,7 +70,7 @@ module ActiveSupport
             mod ||= Module.new
             mod.module_eval do
               define_method(method_name) do |*args, &block|
-                deprecator.deprecation_warning(method_name, options[method_name])
+                deprecator.deprecation_warning(method_name, message)
                 super(*args, &block)
               end
               ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -121,7 +121,7 @@ module ActiveSupport
     #        (Backtrace information…)
     #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
     class DeprecatedConstantProxy < Module
-      def self.new(*args, **kwargs, &block)
+      def self.new(*args, **options, &block)
         object = args.first
 
         return object unless object
@@ -129,7 +129,7 @@ module ActiveSupport
       end
 
       def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance, message: "#{old_const} is deprecated! Use #{new_const} instead.")
-        require "active_support/inflector/methods"
+        Kernel.require "active_support/inflector/methods"
 
         @old_const = old_const
         @new_const = new_const

data/lib/active_support/deprecation/reporting.rb

@@ -6,7 +6,7 @@ module ActiveSupport
   class Deprecation
     module Reporting
       # Whether to print a message (silent mode)
-      attr_accessor :silenced
+      attr_writer :silenced
       # Name of gem where method is deprecated
       attr_accessor :gem_name
 
@@ -20,7 +20,11 @@ module ActiveSupport
 
         callstack ||= caller_locations(2)
         deprecation_message(callstack, message).tap do |m|
-          behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+          if deprecation_disallowed?(message)
+            disallowed_behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+          else
+            behavior.each { |b| b.call(m, callstack, deprecation_horizon, gem_name) }
+          end
         end
       end
 
@@ -33,11 +37,50 @@ module ActiveSupport
       #     ActiveSupport::Deprecation.warn('something broke!')
       #   end
       #   # => nil
-      def silence
-        old_silenced, @silenced = @silenced, true
-        yield
-      ensure
-        @silenced = old_silenced
+      def silence(&block)
+        @silenced_thread.bind(true, &block)
+      end
+
+      # Allow previously disallowed deprecation warnings within the block.
+      # <tt>allowed_warnings</tt> can be an array containing strings, symbols, or regular
+      # expressions. (Symbols are treated as strings). These are compared against
+      # the text of deprecation warning messages generated within the block.
+      # Matching warnings will be exempt from the rules set by
+      # +ActiveSupport::Deprecation.disallowed_warnings+
+      #
+      # The optional <tt>if:</tt> argument accepts a truthy/falsy value or an object that
+      # responds to <tt>.call</tt>. If truthy, then matching warnings will be allowed.
+      # If falsey then the method yields to the block without allowing the warning.
+      #
+      #   ActiveSupport::Deprecation.disallowed_behavior = :raise
+      #   ActiveSupport::Deprecation.disallowed_warnings = [
+      #     "something broke"
+      #   ]
+      #
+      #   ActiveSupport::Deprecation.warn('something broke!')
+      #   # => ActiveSupport::DeprecationException
+      #
+      #   ActiveSupport::Deprecation.allow ['something broke'] do
+      #     ActiveSupport::Deprecation.warn('something broke!')
+      #   end
+      #   # => nil
+      #
+      #   ActiveSupport::Deprecation.allow ['something broke'], if: Rails.env.production? do
+      #     ActiveSupport::Deprecation.warn('something broke!')
+      #   end
+      #   # => ActiveSupport::DeprecationException for dev/test, nil for production
+      def allow(allowed_warnings = :all, if: true, &block)
+        conditional = binding.local_variable_get(:if)
+        conditional = conditional.call if conditional.respond_to?(:call)
+        if conditional
+          @explicitly_allowed_warnings.bind(allowed_warnings, &block)
+        else
+          yield
+        end
+      end
+
+      def silenced
+        @silenced || @silenced_thread.value
       end
 
       def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)

data/lib/active_support/deprecation.rb

@@ -17,15 +17,18 @@ module ActiveSupport
     require "active_support/deprecation/instance_delegator"
     require "active_support/deprecation/behaviors"
     require "active_support/deprecation/reporting"
+    require "active_support/deprecation/disallowed"
     require "active_support/deprecation/constant_accessor"
     require "active_support/deprecation/method_wrappers"
     require "active_support/deprecation/proxy_wrappers"
     require "active_support/core_ext/module/deprecation"
+    require "concurrent/atomic/thread_local_var"
 
     include Singleton
     include InstanceDelegator
     include Behavior
     include Reporting
+    include Disallowed
     include MethodWrapper
 
     # The version number in which the deprecated behavior will be removed, by default.
@@ -35,12 +38,14 @@ module ActiveSupport
     # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "6.1", gem_name = "Rails")
+    def initialize(deprecation_horizon = "6.2", gem_name = "Rails")
       self.gem_name = gem_name
       self.deprecation_horizon = deprecation_horizon
       # By default, warnings are not silenced and debugging is off.
       self.silenced = false
       self.debug = false
+      @silenced_thread = Concurrent::ThreadLocalVar.new(false)
+      @explicitly_allowed_warnings = Concurrent::ThreadLocalVar.new(nil)
     end
   end
 end

data/lib/active_support/descendants_tracker.rb

@@ -13,6 +13,7 @@ module ActiveSupport
         descendants = @@direct_descendants[klass]
         descendants ? descendants.to_a : []
       end
+      alias_method :subclasses, :direct_descendants
 
       def descendants(klass)
         arr = []
@@ -59,6 +60,7 @@ module ActiveSupport
     def direct_descendants
       DescendantsTracker.direct_descendants(self)
     end
+    alias_method :subclasses, :direct_descendants
 
     def descendants
       DescendantsTracker.descendants(self)
@@ -77,15 +79,17 @@ module ActiveSupport
       end
 
       def <<(klass)
-        cleanup!
         @refs << WeakRef.new(klass)
       end
 
       def each
-        @refs.each do |ref|
+        @refs.reject! do |ref|
           yield ref.__getobj__
+          false
         rescue WeakRef::RefError
+          true
         end
+        self
       end
 
       def refs_size