weak 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd14986fea0acdca768d90fa686370e5e2f92207e4bd82a55cbc17b53fa6f81d
-  data.tar.gz: b3f39735d13792b488a837841fa2c3b10f164955bbb8e791127504f2236e5a8f
+  metadata.gz: de4d3b085987c7e4374f7921d0312730ddb5941170ca06328eb239a8928bb649
+  data.tar.gz: 199ae4143167bf3351cfd9c21d3525434692bf0ba04085bfc60df0dc0dde7cfd
 SHA512:
-  metadata.gz: b005c22ef5a2a7d4d43a75ef6633e3b1c29347943e71515894885c134f014e4ecd4152522f758052a2a33c847417c3eaa2358ade5f3b5a22993c657a59aa63e1
-  data.tar.gz: a76fa37a0b49c4dc305c899e1de3111452bb4f668779b688b13508cf16bc47759c74dfa5345d11a5e3a42b8d556ea6d27d0c742e8d11accf354e3f0f6d791389
+  metadata.gz: c386274b05c8a4bb347673cd51aff04977c88ecee16ba5678b10ffd95e78b56397752df958b3e79b8ae5d76034f32eb94c642cfc3de0aaca8117e7e3f9792969
+  data.tar.gz: fc50a65f6d0ccc286430d0917f102b742c90c1becbd9cfa22730e57f298da6ceba5c7011ddded19b767af89a2a5253f111c8e44428547e9ab2f65f656e9f9dcd

data/CHANGELOG.md

@@ -2,40 +2,72 @@
 
 ## [Unreleased]
 
-## [0.3.1] - 2026-01-16
+## [0.4.0] - 2026-06-23
 
-- Update changelog of 0.3.0 release
+### Changed
 
-## [0.3.0] - 2026-01-16
+- Improve documentation for `Weak::Set#delete?`
+- Clarify humanistic usage policy
+- Update Github actions
+- Use [Common Changelog](https://common-changelog.org) style for the entire changelog
+- Return the resolved proc from `Weak::Map#default_proc=` instead if the given value
 
-### Features
+### Added
 
-- Add `Weak::Cache` as a thread-safe wrapper around `Weak::Map` to provide an object cache.
+- Add documentation for remaining `Weak::Cache` methods.
+- Run specs for JRuby 10.1
+
+### Fixed
+
+- Fix error reporting on Github CI
+- Do not clear `Weak::Map#default` if the object given to `Weak::Map#default_proc=` is invalid
+
+## [0.3.1] - 2026-01-16
+
+### Fixed
 
-### Bug Fixes
+- Update changelog of 0.3.0 release
 
-- Fix `Weak::Map#store` method alias to `Weak::Map#[]=`. Previously, it was errouneously aliased to `Weak::Map#[]`.
+## [0.3.0] - 2026-01-16
 
-### Improvements
+### Changed
 
 - Adapt `Weak::Set#inspect` output to more resemble the output of `Set#inspect` in Ruby 4.0
 - Fix typos in code documentation
 - Use `require_relative` instead of require for all gem files
-- Add addititional specs for `Weak::Map`
 - Clarify humanistic usage policy
 
+### Added
+
+- Add `Weak::Cache` as a thread-safe wrapper around `Weak::Map` to provide an object cache.
+- Add addititional specs for `Weak::Map`
+
+### Fixed
+
+- Fix `Weak::Map#store` method alias to `Weak::Map#[]=`. Previously, it was erroneously aliased to `Weak::Map#[]`.
+
 ## [0.2.1] - 2025-12-27
 
-- Fix typos in code documentation
+### Changed
+
 - Ignore some unnecessary methods defined on some `Weak::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.
+
+### Added
+
 - Add more details about the gem version in `Weak::Version`
+- Run specs on JRuby 10 in Github Actions
+
+### Fixed
+
 - Handle object cycles in `pretty_print`.
+- Retry TruffleRuby rspec runs on Github Actions to avoid random failures due to flakey GC.
+- Fix typos in code documentation
 
 ## [0.2.0] - 2025-04-09
 
+### Added
+
 - Add `Weak::Map#delete_if`
 - Add `Weak::Map#keep_if`
 - Add `Weak::Map#reject!`
@@ -45,6 +77,8 @@
 
 ## [0.1.0] - 2025-03-14
 
+### Added
+
 - Initial version of `Weak::Set` to store an unordered collection of objects.
 - Initial version of `Weak::Map` to store key-value pairs of objects.
 - Support for Ruby 3.0 using the following impementations
@@ -54,4 +88,4 @@
 
 ## [0.0.1.pre] - 2025-02-05
 
-- First blank slate
+First blank slate

data/README.md

@@ -1,21 +1,21 @@
 # Weak
 
 [![gem version badge](https://badge.fury.io/rb/weak.svg)](https://rubygems.org/gems/weak)
-[![license badge](https://img.shields.io/badge/license-MIT-brightgreen.svg)](#license)
+[![license badge](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://github.com/meineerde/weak/blob/main/LICENSE.txt)
 [![github repo badge](https://img.shields.io/badge/github-meineerde/weak-blue.svg)](https://github.com/meineerde/weak)
 [![documentation badge](https://img.shields.io/badge/docs-rubydoc.info-blue.svg)](https://www.rubydoc.info/gems/weak)
 
 [![code style: standard badge](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/standardrb/standard)
-[![CI status badge](https://github.com/meineerde/weak/actions/workflows/ci.yml/badge.svg)](https://github.com/meineerde/weak/actions/workflows/ci.yml)
+[![CI status badge](https://github.com/meineerde/weak/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/meineerde/weak/actions/workflows/ci.yml?query=branch%3Amain)
 [![Coverage Status](https://coveralls.io/repos/github/meineerde/weak/badge.svg?branch=main)](https://coveralls.io/github/meineerde/weak?branch=main)
 
-Weak is a Ruby library which implements collections of unordered values without strong object references.
+Weak is a Ruby library which implements collections of unordered values with weak object references.
 
 We provide multiple classes which behave similar to their standard-library counterparts. However, all elements are only weakly referenced. That way, all elements can be garbage collected and silently removed from the collection unless they are still referenced from some other live object.
 
 ## Weak::Set 
 
-`Weak::Set` behaves similar to the [Set](https://docs.ruby-lang.org/en/3.4/Set.html) class of the Ruby standard library, but all values are only weakly referenced. That way, all values can be garbage collected and silently removed from the set unless they are still referenced from some other live object.
+[`Weak::Set`](https://www.rubydoc.info/gems/weak/Weak/Set) behaves similar to the [Set](https://docs.ruby-lang.org/en/3.4/Set.html) class of the Ruby standard library, but all values are only weakly referenced. That way, all values can be garbage collected and silently removed from the set unless they are still referenced from some other live object.
 
 > [!CAUTION]
 > `Weak::Set` objects are not inherently thread-safe. When accessing a weak set from multiple threads or fibers, you MUST use a mutex or another locking mechanism.
@@ -43,11 +43,11 @@ set
 
 ## Weak::Map
 
-`Weak::Map` behaves similar to a `Hash` or an `ObjectSpace::WeakMap` in Ruby (aka. MRI, aka. YARV). 
+[`Weak::Map`](https://www.rubydoc.info/gems/weak/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`.
 
 > [!CAUTION]
-> `Weak::Map` objects are not inherently thread-safe. When accessing a weak map from multiple threads or fibers, you MUST use a mutex or another locking mechanism.
+> `Weak::Map` objects are not inherently thread-safe. When accessing a weak map from multiple threads or fibers, you MUST use a mutex or another locking mechanism. You can also use `Weak::Cache` as a thread-safe option.
 
 Compared to the `Hash` class, there are a few differences:
 
@@ -72,7 +72,7 @@ map
 
 ## Weak::Cache
 
-`Weak::Cache` is a thread-safe wrapper around `Weak::Map`. The class behaves similar to an `ActiveSupport::Cache::Store`.
+[`Weak::Cache`](https://www.rubydoc.info/gems/weak/Weak/Cache) is a thread-safe wrapper around `Weak::Map`. The class behaves similar to an `ActiveSupport::Cache::Store`.
 
 > [!TIP]
 > `Weak::Cache` objects can safely be used from multiple threads and fibers concurrently without any additional locks.
@@ -100,7 +100,7 @@ Please refer to the documentation at:
 - [📘 Documentation](https://www.rubydoc.info/gems/weak)
 - [💥 Development Documentation](https://www.rubydoc.info/github/meineerde/weak) of the [main branch](https://github.com/meineerde/weak/tree/main)
 
-The Weak collections use Ruby's [ObjectSpace::WeakMap](https://docs.ruby-lang.org/en/3.4/ObjectSpace/WeakMap.html) under the hood. Unfortunately, different Ruby implementations and versions such as Ruby (aka. MRI, aka. YARV), JRuby, or TruffleRuby show quite diverse behavior in their respective `ObjectSpace::WeakMap` implementations. To provide a unified behavior on all supported Rubies, we use multiple different storage strategies.
+The Weak collections use Ruby's [ObjectSpace::WeakMap](https://docs.ruby-lang.org/en/3.4/ObjectSpace/WeakMap.html) under the hood. Unfortunately, different Ruby implementations and versions such as Ruby (aka. MRI, aka. YARV), JRuby, or TruffleRuby implement diverse behavior in their respective `ObjectSpace::WeakMap` implementations. To provide a unified behavior on all supported Rubies, we use multiple different storage strategies.
 
 The appropriate strategy is selected automatically. Their exposed behavior should be identical across all implementations. If you experience diverging behavior, we consider this a bug. Please [open an issue](https://github.com/meineerde/weak/issues/new) and describe the diverging or unexpected behavior.
 
@@ -246,7 +246,7 @@ end
 
 ### Weak::Cache Example
 
-We can simplify the above example by using `Weak::Cache`.
+Insted of manually locking a `Weak::Map` to get or create the lock for provided `object` as in the above example, we can leverage a `Weak::Cache` object which is inherently threadsafe. This allows us to update the above example as follows:
 
 ```ruby
 require "weak/cache"
@@ -293,9 +293,9 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/meinee
 
 Weak is available as free and open source under the terms of the [MIT License](https://github.com/meineerde/weak/blob/main/LICENSE.txt).
 
-This license does not preclude you from using Weak with AI-encumbered or AI-associated projects, but you do not have the author's consent to do so. This may seem like a contradiction, but copyright is a blunt tool that does not in general have the humanistic nuance to describe something like "you can legally do this thing, but if you do, you're an asshole."
+You do not have the author's consent to use Weak in projects associated with so-called "AI" (generative AI, LLMs, ...), even though the MIT license does not specifically preclude you from doing so. This may seem like a contradiction, but copyright is a blunt tool that does not in general have the humanistic nuance to describe something like "you can legally do this thing, but if you do, you're an asshole."
 
-We also explicitly affirm: Trans Rights Are Human Rights. If you do not agree, please refrain from using Weak.
+We also explicitly affirm: Trans Rights Are Human Rights. We explicitly discourage the usage of Weak in any environment where this basic decency is not universally afforded.
 
 (Thanks to [Cassandra Granade](https://codeberg.org/cgranade/do#license-and-ai-policy) for the inspiration.)
 

data/lib/weak/cache.rb

@@ -65,6 +65,7 @@ module Weak
       @mutex.synchronize { super }
     end
 
+    # (see Weak::Map#each_key)
     def each_key(&block)
       return enum_for(__method__) { size } unless block_given?
       keys.each(&block)
@@ -83,8 +84,8 @@ module Weak
     alias_method :include?, :exist?
     alias_method :key?, :exist?
 
-    # Fetches data from the cache, using the given `key`. If there is a value in
-    # the cache for the given key, that value is returned.
+    # Fetches or sets data from the cache, using the given `key`. If there is a
+    # value in the cache for the given key, that value is returned.
     #
     # If there is no value in the cache (a cache miss), then the given block
     # will be passed the key and executed in the event of a cache miss. The
@@ -122,6 +123,9 @@ module Weak
       self
     end
 
+    # @return [String] a string containing a human-readable representation of
+    #   the weak cache, e.g.,
+    #   `"#<Weak::Cache {key1 => value1, key2 => value2, ...}>"`
     def inspect
       @mutex.synchronize { "#<#{self.class} #{@map._inspect}>" }
     end
@@ -155,6 +159,7 @@ module Weak
     end
     alias_method :[], :read
 
+    # (see Weak::Map#size)
     def size
       @mutex.synchronize { @map.size }
     end

data/lib/weak/map/strong_keys.rb

@@ -39,7 +39,7 @@ module Weak
     #
     # The `ObjectSpace::WeakMap` does not allow to explicitly delete entries. We
     # emulate this by setting the garbage-collectible value of a deleted entry
-    # to a simple new object. This value will be garbage collected on the next
+    # to a new "empty" object. This object will be garbage collected on the next
     # GC run which will then remove the entry. When accessing elements, we
     # delete and filter out these recently deleted entries.
     module StrongKeys

data/lib/weak/map/weak_keys.rb

@@ -17,10 +17,10 @@ module Weak
     # the key or the value can be independently garbage collected. If either of
     # them vanishes, the entry is removed.
     #
-    # The `ObjectSpace::WeakMap` does not allow to explicitly delete entries.
-    # We emulate this by setting the garbage-collectible value of a deleted
-    # entry to a simple new object. This value will be garbage collected on the
-    # next GC run which will then remove the entry. When accessing elements, we
+    # The `ObjectSpace::WeakMap` does not allow to explicitly delete entries. We
+    # emulate this by setting the garbage-collectible value of a deleted entry
+    # to a new "empty" object. This value will be garbage collected on the next
+    # GC run which will then remove the entry. When accessing elements, we
     # delete and filter out these recently deleted entries.
     module WeakKeys
       include Deletable

data/lib/weak/map.rb

@@ -39,8 +39,8 @@ module Weak
   #
   # ## Implementation Details
   #
-  # The various Ruby implementations and versions show quite diverse behavior in
-  # their respective `ObjectSpace::WeakMap` implementations. To provide a
+  # The supported Ruby implementations and versions implement diverse behavior
+  # in their respective `ObjectSpace::WeakMap` implementations. To provide a
   # unified behavior on all implementations, we use different storage
   # strategies:
   #
@@ -406,10 +406,9 @@ module Weak
     # @return [Proc, nil] the new default proc
     # @raise [TypeError] if the given `proc` can not be converted to a `Proc`.
     def default_proc=(proc)
-      @default_value = nil
-      return @default_proc = nil if proc.nil?
-
-      if Proc === proc
+      if proc.nil?
+        default_proc = nil
+      elsif Proc === proc
         default_proc = proc
       elsif proc.respond_to?(:to_proc)
         default_proc = proc.to_proc
@@ -421,16 +420,16 @@ module Weak
         raise TypeError, "no implicit conversion of #{proc.class} into Proc"
       end
 
-      if default_proc.lambda?
+      if default_proc&.lambda?
         arity = default_proc.arity
         if arity != 2 && (arity >= 0 || arity < -3)
           arity = -arity - 1 if arity < 0
           raise TypeError, "default_proc takes two arguments (2 for #{arity})"
         end
       end
-      @default_proc = default_proc
 
-      proc
+      @default_value = nil
+      @default_proc = default_proc
     end
 
     # Deletes every key-value pair from `self` for which the given block

data/lib/weak/set/strong_keys.rb

@@ -24,11 +24,11 @@ module Weak
     # `Integer`, the object_id is generally is not garbage collected anyway but
     # allows to uniquely identity the object.
     #
-    # The `ObjectSpace::WeakMap` class does not allow to explicitly delete
-    # entries. We emulate this by setting the garbage-collectible value of a
-    # deleted entry to a simple new object. This value will be garbage collected
-    # on the next GC run which will then remove the entry. When accessing
-    # elements, we delete and filter out these recently deleted entries.
+    # The `ObjectSpace::WeakMap` does not allow to explicitly delete entries. We
+    # emulate this by setting the garbage-collectible value of a deleted entry
+    # to a new "empty" object. This value will be garbage collected on the next
+    # GC run which will then remove the entry. When accessing elements, we
+    # delete and filter out these recently deleted entries.
     module StrongKeys
       class DeletedEntry; end
       private_constant :DeletedEntry

data/lib/weak/set/weak_keys.rb

@@ -16,7 +16,7 @@ module Weak
     #
     # The `ObjectSpace::WeakMap` does not allow to explicitly delete entries. We
     # emulate this by setting the garbage-collectible value of a deleted entry
-    # to a simple new object. This value will be garbage collected on the next
+    # to a new "empty" object. This value will be garbage collected on the next
     # GC run which will then remove the entry. When accessing elements, we
     # delete and filter out these recently deleted entries.
     module WeakKeys

data/lib/weak/set.rb

@@ -37,8 +37,8 @@ module Weak
   #
   # ## Implementation Details
   #
-  # The various Ruby implementations and versions show quite diverse behavior in
-  # their respective `ObjectSpace::WeakMap` implementations. To provide a
+  # The supported Ruby implementations and versions implement diverse behavior
+  # in their respective `ObjectSpace::WeakMap` implementations. To provide a
   # unified behavior on all implementations, we use different storage
   # strategies:
   #
@@ -125,12 +125,15 @@ module Weak
     #   @return [self]
 
     # @!macro weak_set_method_delete_question
-    #   Deletes the given object from `self` and returns `self` if it was
-    #   present in the set. If the object was not in the set, returns `nil`.
+    #   Deletes the given object from `self` and returns `self` if the given
+    #   object was present in the set. If the object was not in the set,
+    #   returns `nil`.
     #
     #   @param obj [Object]
-    #   @return [self, nil] `self` if the given object was deleted from the set
-    #     or `nil` if the object was not part of the set
+    #   @return [self, nil] `self` if the given object was present in the set
+    #     and was deleted accordingly or `nil` if the object was not part of
+    #     the set
+    #   @see Weak::Set#delete
     #   @!macro weak_set_note_object_equality
 
     # @!macro weak_set_method_each
@@ -424,6 +427,7 @@ module Weak
     #
     # @param obj [Object] an object to delete from the weak set
     # @return [self] always returns self
+    # @see #delete?
     # @!macro weak_set_note_object_equality
     def delete(obj)
       delete?(obj)

data/lib/weak/version.rb

@@ -13,10 +13,10 @@ module Weak
     MAJOR = 0
     # MINOR version. It is incremented after adding functionality in a
     # backwards-compatible manner
-    MINOR = 3
+    MINOR = 4
     # PATCH version. It is incremented when making backwards-compatible
     # bug-fixes.
-    PATCH = 1
+    PATCH = 0
     # PRERELEASE suffix. Set to a alphanumeric string on any pre-release
     # versions like beta or RC releases; `nil` on regular releases
     PRERELEASE = nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: weak
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Holger Just
@@ -10,10 +10,9 @@ cert_chain: []
 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
-  objects and a Weak::Map class to store a key-value map. The collection
-  classes only hold weak references to all elements so they can be
-  garbage-collected when there are no more references left.
+  The Weak library provides collections of unordered values. Each of the
+  provided collection classes only holds weak references to all elements so
+  they can be garbage-collected when there are no more references left.
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -47,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.3.1
+  documentation_uri: https://www.rubydoc.info/gems/weak/0.4.0
 rdoc_options: []
 require_paths:
 - lib