weak 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d9cec118afb4ce760b9f1881b0489f9e9b1954ad5c20727d8d1124f9d80027d
-  data.tar.gz: f0fd0cef1c7ce6403fb12630b880cb262063bc759100cfc4a6c7896cd0721e98
+  metadata.gz: 1495109d765259effd2efb1f7d97c7ad7e71e060ecb1d8f8f6cd6386e3a4d93c
+  data.tar.gz: 73be12838b3bdb16f45215dd9b07152e798d62130ca0bdfbca999b57a21ae25d
 SHA512:
-  metadata.gz: c91a2284ad2a25a96ede2f44fcb2e6ed94d08342d83fefe3096c867385369b5ad48977fea610f611894ed763e981cb1b424dd84c23471ba9fb9bc3c19941b8c4
-  data.tar.gz: 2bfd81fc7bb755ee7156a30527478c745dd10e8fff4b5865af823b3726c7105302d446aea9afc3e8c5d4e51ce612e28005c98cb8af5b0a76f98891aa0313cf36
+  metadata.gz: 35c2aa978606c8c1bd1c83838e9eb418eba8e4bada89936675fcb82c6a6a24304da7e34a56b38cf2bab42fd0b682efcf2577c2fecb4fd2c7fb02344869ab3cfd
+  data.tar.gz: 47e6c245cfe310e9ad7b538028cac0e36531b3c856ac3ec6efbb66126ac5c51f26dbecc03a516eca9598f8c81f02de5e26a51c435cc2f40a86a7d39ff2253793

data/.yardopts

@@ -0,0 +1,12 @@
+--protected
+--no-private
+--markup markdown
+--title=Weak
+--template default
+--default-return undocumented
+lib/**/*.rb
+-
+README.md
+CHANGELOG.md
+CODE_OF_CONDUCT.md
+LICENSE.txt

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [Unreleased]
+
+## [0.2.1] - 2025-12-27
+
+- Fix typos in code documentation
+- Ignore some unnecessary methods defined on some `Set` implementations in `set_spec`
+- Run specs on JRuby 10 in Github Actions
+- Retry TruffleRuby rspec runs on Github Actions to avoid random failures due to flakey GC.
+- Extract UNDEFINED to its own file and require it where used.
+- Add more details about the gem version in `Weak::Version`
+- Handle object cycles in `pretty_print`.
+
+## [0.2.0] - 2025-04-09
+
+- Add `Weak::Map#delete_if`
+- Add `Weak::Map#keep_if`
+- Add `Weak::Map#reject!`
+- Add `Weak::Map#replace`
+- Add `Weak::Map#select!`
+- Add `Weak::Map#values_at`
+
 ## [0.1.0] - 2025-03-14
 
 - Initial version of `Weak::Set` to store an unordered collection of objects.

data/README.md

@@ -1,8 +1,7 @@
 # Weak
 
 [![gem version badge](https://badge.fury.io/rb/weak.svg)](https://rubygems.org/gems/weak)
-[![CI status badge](https://github.com/meineerde/weak/actions/workflows/ci.yml/badge.svg)](https://github.com/meineerde/weak/actions/workflows/ci.yml)
-[![Coverage Status](https://coveralls.io/repos/github/meineerde/weak/badge.svg?branch=main)](https://coveralls.io/github/meineerde/weak?branch=main)
+[![github repo badge](https://img.shields.io/badge/github-repo-blue?logo=github)](https://github.com/meineerde/weak)
 
 Weak is a Ruby library which implements collections of unordered values without strong object references.
 
@@ -38,11 +37,11 @@ set
 `Weak::Map` behaves similar to a `Hash` or an `ObjectSpace::WeakMap` in Ruby (aka. MRI, aka. YARV). 
 Both keys and values are weak references, allowing either of them to be garbage collected. If either the key or the value of a pair is garbage collected, the entire pair will be removed from the `Weak::Map`.
 
-Compared to the `Set` class however, there are a few differences:
+Compared to the `Hash` class however, there are a few differences:
 
   - Key and value references are weak, allowing each key-value pair to be garbage collected unless there is a strong reference to boith the key and the value somewhere else.
   - We do not necessarily retain the order of elements as they are inserted into the `Weak::Map`. You should not rely on a specific order.
-  - Map membership is governed by object identity of the key rather than by using the `hash` and `eql?` methods of the elements. A `Weak::Map` thus works similat to a `Hash` marked as [compare_by_identity](https://docs.ruby-lang.org/en/3.4/Hash.html#method-i-compare_by_identity).
+  - Map membership is governed by object identity of the key rather than by using its `hash` and `eql?` methods. A `Weak::Map` thus works similar to a `Hash` marked as [compare_by_identity](https://docs.ruby-lang.org/en/3.4/Hash.html#method-i-compare_by_identity).
   - You can freely change both keys and values added to the `Weak::Map`.
 
 ```ruby
@@ -64,7 +63,7 @@ map
 Please refer to the documentation at:
 
 - [📘 Documentation](https://www.rubydoc.info/gems/weak)
-- [💥 Development Documentation](https://www.rubydoc.info/github/meineerde/weak/main) of the [main branch](https://github.com/meineerde/weak/tree/main)
+- [💥 Development Documentation](https://www.rubydoc.info/github/meineerde/weak) of the [main branch](https://github.com/meineerde/weak/tree/main)
 
 > [!WARNING]
 > The Weak collections are not inherently thread-safe. When accessing a collection from multiple threads or fibers, you MUST use a mutex or another locking mechanism.
@@ -213,6 +212,9 @@ end
 
 ## Development
 
+[![CI status badge](https://github.com/meineerde/weak/actions/workflows/ci.yml/badge.svg)](https://github.com/meineerde/weak/actions/workflows/ci.yml)
+[![Coverage Status](https://coveralls.io/repos/github/meineerde/weak/badge.svg?branch=main)](https://coveralls.io/github/meineerde/weak?branch=main)
+
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 [![code style: standard badge](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/standardrb/standard)
@@ -225,7 +227,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/meinee
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).
 
 ## Code of Conduct
 

data/lib/weak/map/abstract_strong_keys.rb

@@ -34,9 +34,9 @@ module Weak
       private
 
       # This method is called during {#_get}. It generally needs to be
-      # overwritten in a "sub"-mdule to automatically cleanup any internal data.
-      # The implemented `auto_prune` method should quickly check if a prune is
-      # necessary and then either call the `prune` method or return.
+      # overwritten in a "sub"-module to automatically cleanup any internal
+      # data. The implemented `auto_prune` method should quickly check if a
+      # prune is necessary and then either call the `prune` method or return.
       #
       # @return [void]
       def auto_prune

data/lib/weak/map/strong_keys.rb

@@ -8,6 +8,7 @@
 require "set"
 
 require "weak/map/abstract_strong_keys"
+require "weak/undefined"
 
 ##
 module Weak

data/lib/weak/map/strong_secondary_keys.rb

@@ -8,6 +8,7 @@
 require "set"
 
 require "weak/map/abstract_strong_keys"
+require "weak/undefined"
 
 ##
 module Weak

data/lib/weak/map/weak_keys.rb

@@ -6,6 +6,7 @@
 # of the MIT license. See the LICENSE.txt file for details.
 
 require "weak/map/deletable"
+require "weak/undefined"
 
 ##
 module Weak

data/lib/weak/map/weak_keys_with_delete.rb

@@ -5,6 +5,8 @@
 # This software may be modified and distributed under the terms
 # of the MIT license. See the LICENSE.txt file for details.
 
+require "weak/undefined"
+
 ##
 module Weak
   class Map

data/lib/weak/map.rb

@@ -5,10 +5,11 @@
 # This software may be modified and distributed under the terms
 # of the MIT license. See the LICENSE.txt file for details.
 
-require_relative "map/weak_keys_with_delete"
-require_relative "map/weak_keys"
-require_relative "map/strong_keys"
-require_relative "map/strong_secondary_keys"
+require "weak/map/weak_keys_with_delete"
+require "weak/map/weak_keys"
+require "weak/map/strong_keys"
+require "weak/map/strong_secondary_keys"
+require "weak/undefined"
 
 ##
 module Weak
@@ -270,15 +271,14 @@ module Weak
     INSPECT_KEY = :__inspect_key__
     private_constant :INSPECT_KEY
 
-    # @param maps [Array<#each_pair>] a list of maps which should be
-    #   merged into the new {Weak::Map}
+    # @param maps [Array<Weak::Map, Hash, #to_hash>] a list of maps which should
+    #   be merged into the new {Weak::Map}
     # @return [Weak::Map] a new {Weak::Map} object populated with the given
     #   objects, if any. With no argument, returns a new empty {Weak::Map}.
     # @example
     #   hash = {foo: 0, bar: 1, baz: 2}
     #   Weak::Map[hash]
     #   # => #<Weak::Map {:foo=>0, :bar=>1, :baz=>2}>
-
     def self.[](*maps)
       Weak::Map.new.merge!(*maps)
     end
@@ -432,6 +432,26 @@ module Weak
       proc
     end
 
+    # Deletes every key-value pair from `self` for which the given block
+    # evaluates to a truthy value.
+    #
+    # If no block is given, an `Enumerator` is returned instead.
+    #
+    # @yield [key, value] calls the given block once for each key in the map
+    # @yieldparam key [Object] a key
+    # @yieldparam value [Object] the corresponding value
+    # @return [Enumerator, self] `self` if a block was given or an `Enumerator`
+    #   if no block was given.
+    # @see reject!
+    def delete_if(&block)
+      return enum_for(__method__) { size } unless block_given?
+
+      each do |key, value|
+        delete(key) if yield(key, value)
+      end
+      self
+    end
+
     # @return [Boolean] `true` if `self` contains no elements
     def empty?
       size == 0
@@ -467,25 +487,45 @@ module Weak
 
       object_ids << object_id
       begin
-        elements = to_a.sort_by! { |k, _v| k.__id__ }.to_h.inspect[1..-2]
-        "#<#{self.class} {#{elements}}>"
+        elements = to_a.sort_by! { |k, _v| k.__id__ }.to_h
+        "#<#{self.class} #{elements}>"
       ensure
         object_ids.pop
       end
     end
     alias_method :to_s, :inspect
 
+    # Deletes every key-value pair from `self` for which the given block
+    # evaluates to a falsey value.
+    #
+    # If no block is given, an `Enumerator` is returned instead.
+    #
+    # @yield [key, value] calls the given block once for each key in the map
+    # @yieldparam key [String] a hash key
+    # @yieldparam value [Object] the corresponding hash value
+    # @return [Enumerator, self] `self` if a block was given, an `Enumerator`
+    #  if no block was given.
+    # @see select!
+    def keep_if(&block)
+      return enum_for(__method__) { size } unless block_given?
+
+      each do |key, value|
+        delete(key) unless yield(key, value)
+      end
+      self
+    end
+
     # Returns the new {Weak::Map} formed by merging each of `other_maps` into a
     # copy of `self`.
     #
-    # Each argument in other_maos must be respond to `each_pair`, e.g. a
-    # {Weak::Map} or a `Hash`.
+    # Each argument in `other_maps` must be either a {Weak::Map}, a Hash object
+    # or must be transformable to a Hash by calling `each_hash` on it.
     #
     # With arguments and no block:
     #
     #   - Returns a new {Weak::Map}, after the given maps are merged into a copy
     #     of `self`.
-    #   - The given hashes are merged left to right.
+    #   - The given maps are merged left to right.
     #   - Each duplicate-key entry’s value overwrites the previous value.
     #
     # Example:
@@ -502,7 +542,7 @@ module Weak
     # With arguments and a block:
     #
     #   - Returns `self`, after the given maps are merged.
-    #   - The given hashes are merged left to right.
+    #   - The given maps are merged left to right.
     #   - For each duplicate key:
     #     - Calls the block with the key and the old and new values.
     #     - The block’s return value becomes the new value for the entry.
@@ -526,8 +566,8 @@ module Weak
     #   - Returns a copy of `self`.
     #   - The block, if given, is ignored.
     #
-    # @param other_maps [Array<#each_pair>] a list of maps which should be
-    #   merged into a copy of `self`
+    # @param other_maps [Array<Weak::Map, Hash, #to_hash>] a list of maps which
+    #   should be merged into a copy of `self`
     # @yield [key, old_value, new_value] If `self` already contains a value for
     #   a key, we yield the key, the old value from `self` and the new value
     #   from the given map and use the value returned from the block as the new
@@ -551,15 +591,92 @@ module Weak
       end
     end
 
+    # @!visibility private
+    def pretty_print_cycle(pp)
+      pp.text "#<#{self.class} {#{"..." unless empty?}}>"
+    end
+
+    # Deletes every key-value pair from `self` for which the given block
+    # evaluates to a truethy value.
+    #
+    # Equivalent to {#delete_if}, but returns `nil` if no changes were made.
+    #
+    # If no block is given, an `Enumerator` is returned instead.
+    #
+    # @yield [key, value] calls the given block once for each key in the map
+    # @yieldparam key [Object] a key
+    # @return [Enumerator, self, nil] `self` if a block was given and some
+    #    element(s) were deleted, `nil` if a block was given but no keys were
+    #   deleted, or an `Enumerator` if no block was given.
+    # #see #delete_if
+    def reject!(&block)
+      return enum_for(__method__) { size } unless block_given?
+
+      deleted_anything = false
+      each do |key, value|
+        next unless yield(key, value)
+
+        delete(key)
+        deleted_anything = true
+      end
+
+      self if deleted_anything
+    end
+
+    # Replaces the contents of `self` with the contents of the given Hash-like
+    # object and returns `self`.
+    #
+    # If the given `map` defines a {#default} value or {#default_proc}, this
+    # will also replace the respective seting in `self`.
+    #
+    # @param map (see #_implicit)
+    # @return [self]
+    # @example
+    #     map = Weak::Map[a: 1, b: 3, c: 1] #=> #<Weak::Map {a: 1, b: 3, c: 1}>
+    #     map.replace({x: :y})              #=> #<Weak::Map {x: :y}>
+    #     map                               #=> #<Weak::Map {x: :y}>
+    def replace(map)
+      initialize_copy(_implicit(map))
+    end
+
+    # Deletes every key-value pair from `self` for which the given block
+    # evaluates to a falsey value.
+    #
+    # Equivalent to {#keep_if}, but returns `nil` if no changes were made.
+    #
+    # If no block is given, an `Enumerator` is returned instead.
+    #
+    # @yield [key, value] calls the given block once for each key in the map
+    # @yieldparam key [Object] a key
+    # @yieldparam value [Object] the corresponding value
+    # @return [Enumerator, self, nil] `self` if a block was given and some
+    #    element(s) were deleted, `nil` if a block was given but nothing was
+    #    deleted, or an `Enumerator` if no block was given.
+    # @see keep_if
+    def select!(&block)
+      return enum_for(__method__) { size } unless block_given?
+
+      deleted_anything = false
+      each do |key, value|
+        next if yield(key, value)
+
+        delete(key)
+        deleted_anything = true
+      end
+
+      self if deleted_anything
+    end
+    alias_method :filter!, :select!
+
     # Merges each of `other_maps` into `self`; returns `self`.
     #
-    # Each argument in other_maos must be respond to `each_pair`, e.g. a
-    # {Weak::Map} or a `Hash`.
+    # Each argument in `other_maps` must be either a {Weak::Map}, a Hash object
+    # or must be transformable to a Hash by calling `each_hash` on it.
     #
     # With arguments and no block:
     #
     #   - Returns self, after the given maps are merged into it.
-    #   - The given hashes are merged left to right.
+    #   - The given maps are merged left to right.
     #   - Each duplicate-key entry’s value overwrites the previous value.
     #
     # Example:
@@ -576,7 +693,7 @@ module Weak
     # With arguments and a block:
     #
     #   - Returns `self`, after the given maps are merged.
-    #   - The given hashes are merged left to right.
+    #   - The given maps are merged left to right.
     #   - For each duplicate key:
     #     - Calls the block with the key and the old and new values.
     #     - The block’s return value becomes the new value for the entry.
@@ -600,8 +717,8 @@ module Weak
     #   - Returns `self`.
     #   - The block, if given, is ignored.
     #
-    # @param other_maps [Array<#each_pair>] a list of maps which should be
-    #   merged into `self`
+    # @param other_maps [Array<Weak::Map, Hash, #to_hash>] a list of maps which
+    #    should be merged into `self`
     # @yield [key, old_value, new_value] If `self` already contains a value for
     #   a key, we yield the key, the old value from `self` and the new value
     #   from the given map and use the value returned from the block as the new
@@ -618,7 +735,7 @@ module Weak
         missing = Object.new
 
         other_maps.each do |map|
-          map.each_pair do |key, value|
+          _implicit(map).each_pair do |key, value|
             old_value = fetch(key, missing)
             value = yield(key, old_value, value) unless missing == old_value
             self[key] = value
@@ -626,7 +743,7 @@ module Weak
         end
       else
         other_maps.each do |map|
-          map.each_pair do |key, value|
+          _implicit(map).each_pair do |key, value|
             self[key] = value
           end
         end
@@ -675,6 +792,25 @@ module Weak
       hash
     end
 
+    # Returns a new `Array` containing values for the given keys:
+    #
+    #     map = Weak::Map[foo: 0, bar: 1, baz: 2]
+    #     map.values_at(:baz, :foo)
+    #     # => [2, 0]
+    #
+    # The default values are returned for any keys that are not found:
+    #
+    #     map.values_at(:hello, :foo)
+    #     # => [nil, 0]
+    #
+    # @param keys [Array<Object>] a list of keys
+    # @return [Array] an `Array` containing the values for the given keys if
+    #   present or the default value if not. The order of the given `keys` is
+    #   preserved.
+    def values_at(*keys)
+      keys.map { |key| self[key] }
+    end
+
     private
 
     # Callback method which is called on the new object during `dup` or `clone`
@@ -710,5 +846,21 @@ module Weak
         )
       end
     end
+
+    # @param map [Weak::Map, Hash, #to_hash] a {Weak::Map} or a Hash object or
+    #   an object which can be converted to a `Hash` by calling `to_hash` on it
+    # @return [Weak::Map, Hash] either a `Weak::Map` or a `Hash` object
+    #   converted from the given `map`
+    # @raise [TypeError] if the given `map` is not a {Weak::Map} and not a
+    #   `Hash`, and could not ge converted to a Hash
+    def _implicit(map)
+      if Weak::Map === map || ::Hash === map
+        map
+      elsif (hash = ::Hash.try_convert(map))
+        hash
+      else
+        raise TypeError, "no implicit conversion of #{map.class} into #{self.class}"
+      end
+    end
   end
 end

data/lib/weak/set.rb

@@ -561,7 +561,7 @@ module Weak
 
     # @!visibility private
     def pretty_print_cycle(pp)
-      pp.text "#<#{self.class} {#{empty? ? "" : "..."}}>"
+      pp.text "#<#{self.class} {#{"..." unless empty?}}>"
     end
 
     # @param other [Weak::Set] a weak set

data/lib/weak/undefined.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Copyright (c) Holger Just
+#
+# This software may be modified and distributed under the terms
+# of the MIT license. See the LICENSE.txt file for details.
+
+require "singleton"
+
+##
+module Weak
+  # A class for the {UNDEFINED} object. Being a singleton, there will only be
+  # exactly one object of this class: the {UNDEFINED} object.
+  #
+  # @private
+  class UndefinedClass
+    include Singleton
+
+    def initialize
+      freeze
+    end
+
+    # @return [String] the string `"UNDEFINED"`
+    def to_s
+      "UNDEFINED"
+    end
+    alias_method :inspect, :to_s
+  end
+
+  # The {UNDEFINED} object can be used as the default value for method arguments
+  # to distinguish it from `nil`.
+  #
+  # @see https://holgerjust.de/2016/detecting-default-arguments-in-ruby/#special-default-value
+  UNDEFINED = UndefinedClass.instance
+end

data/lib/weak/version.rb

@@ -7,8 +7,36 @@
 
 ##
 module Weak
-  # The {Weak} version as a `Gem::Version` string. We follow semantic
-  # versioning.
-  # @see https://semver.org/
-  VERSION = "0.1.0"
+  # Version information about {Weak}}. We follow semantic versioning.
+  module Version
+    # MAJOR version. It is incremented after incompatible API changes
+    MAJOR = 0
+    # MINOR version. It is incremented after adding functionality in a
+    # backwards-compatible manner
+    MINOR = 2
+    # PATCH version. It is incremented when making backwards-compatible
+    # bug-fixes.
+    PATCH = 1
+    # PRERELEASE suffix. Set to a alphanumeric string on any pre-release
+    # versions like beta or RC releases; `nil` on regular releases
+    PRERELEASE = nil
+
+    # The {Weak} version as a `Gem::Version` string. We follow semantic
+    # versioning.
+    # @see https://semver.org/
+    STRING = [MAJOR, MINOR, PATCH, PRERELEASE].compact.join(".").freeze
+
+    # @return [Gem::Version] the {Weak} version as a `Gem::Version` object
+    def self.gem_version
+      Gem::Version.new STRING
+    end
+
+    # @return [String] the Weak version as a `Gem::Version` string
+    def self.to_s
+      STRING
+    end
+  end
+
+  # (see Version::STRING)
+  VERSION = Weak::Version::STRING
 end

data/lib/weak.rb

@@ -5,8 +5,6 @@
 # This software may be modified and distributed under the terms
 # of the MIT license. See the LICENSE.txt file for details.
 
-require "singleton"
-
 require_relative "weak/version"
 require_relative "weak/map"
 require_relative "weak/set"
@@ -19,27 +17,4 @@ require_relative "weak/set"
 # elements can be garbage collected and silently removed from the collection
 # unless they are still referenced from some other live object.
 module Weak
-  # A class for the {UNDEFINED} object. Being a singleton, there will only be
-  # exactly one object of this class: the {UNDEFINED} object.
-  #
-  # @private
-  class UndefinedClass
-    include Singleton
-
-    def initialize
-      freeze
-    end
-
-    # @return [String] the string `"UNDEFINED"`
-    def to_s
-      "UNDEFINED"
-    end
-    alias_method :inspect, :to_s
-  end
-
-  # The {UNDEFINED} object can be used as the default value for method arguments
-  # to distinguish it from `nil`.
-  #
-  # @see https://holgerjust.de/2016/detecting-default-arguments-in-ruby/#special-default-value
-  UNDEFINED = UndefinedClass.instance
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: weak
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Holger Just
 bindir: bin
 cert_chain: []
-date: 2025-03-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |
   The Weak library provides a Weak::Set class to store an unordered list of
@@ -18,6 +18,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
@@ -35,6 +36,7 @@ files:
 - lib/weak/set/strong_secondary_keys.rb
 - lib/weak/set/weak_keys.rb
 - lib/weak/set/weak_keys_with_delete.rb
+- lib/weak/undefined.rb
 - lib/weak/version.rb
 homepage: https://github.com/meineerde/weak
 licenses:
@@ -44,7 +46,7 @@ metadata:
   homepage_uri: https://github.com/meineerde/weak
   source_code_uri: https://github.com/meineerde/weak
   changelog_uri: https://github.com/meineerde/weak/blob/main/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/weak/0.1.0
+  documentation_uri: https://www.rubydoc.info/gems/weak/0.2.1
 rdoc_options: []
 require_paths:
 - lib
@@ -59,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 4.0.3
 specification_version: 4
-summary: Tools to use handle collections of weak-referenced values in Ruby
+summary: Tools to handle collections of weakly-referenced values
 test_files: []