weak_key_map 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a1342b3db5bf5ff1157e1d7b8590699c913cce68685aa72b40492ec7bf8307e4
+  data.tar.gz: 1b08647a4aab5103d70e75bc476bf2745b1f688b981ecbfa2e1ac907c447b006
+SHA512:
+  metadata.gz: a4752359db7288c57dffd016ce0a8cfea8c4a26d7eb9e19cd32f1405c2f1b8f770439f9981a93a92a8767c592fd9711a0244954572c5743d7b0ecc6a0fbfe751
+  data.tar.gz: d95dfc108ecc8da00c1cf27fa12ee84ce06899e458e33f3dc921e5853a3b28ccb9a1f151c02c7445077eb8e633141e023a250d9e0d26fb542ceb6378c0018d09

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# 1.0.0
+* Birthday!

data/Gemfile

@@ -0,0 +1,18 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem "debug"
+  gem "rake"
+end
+
+group :development do
+  gem "appraisal"
+  gem "appraisal-run"
+end
+
+group :test do
+  gem "minitest", "~> 5.0"
+  gem "m", "~> 1.6"
+end

data/README.md

@@ -0,0 +1,37 @@
+## weak_key_map
+
+![Unit Tests](https://github.com/camertron/weak_key_map/actions/workflows/tests.yml/badge.svg?branch=main)
+
+A backport of `ObjectSpace::WeakKeyMap` for Ruby < 3.3
+
+## Introduction
+
+Ruby 3.3 introduced the handy `ObjectSpace::WeakKeyMap` class to complement `ObjectSpace::WeakMap`. The `WeakMap` class holds weak references to both keys _and_ values, meaning if the value for a particular key is garbage collected, the entire key/value pair will be removed from the map. In contrast, the `WeakKeyMap` class only removes values if the _key_ is garbage collected.
+
+This gem is a backport of `WeakKeyMap` for older rubies in the 3.x line.
+
+## Usage
+
+`WeakKeyMap`s work in a very similar fashion to a normal Ruby hash, eg:
+
+```ruby
+map = ObjectSpace::WeakKeyMap.new
+key = "key"
+map[key] = "value"
+map["key"]  # => "value"
+key = nil
+GC.start
+map["key"]  # => nil
+```
+
+## Running Tests
+
+`bundle exec rake` should do the trick.
+
+## License
+
+Licensed under the MIT license. See LICENSE for details.
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler"
+require "rubygems/package_task"
+require "minitest/test_task"
+
+task default: :test
+
+Minitest::TestTask.create
+
+Bundler::GemHelper.install_tasks

data/lib/weak_key_map/impl.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "weakref"
+
+module ObjectSpace
+  class WeakKeyMap
+    def initialize
+      @map = {}
+      @refs = {}
+    end
+
+    def [](key)
+      hash = key.hash
+      ref = @refs[hash]
+      return nil unless ref
+      return @map[hash] if ref.weakref_alive?
+
+      @map.delete(hash)
+      @refs.delete(hash)
+
+      nil
+    end
+
+    def []=(key, value)
+      case key
+      when true, false, nil, Integer, Float, Symbol
+        raise ArgumentError, "WeakKeyMap keys must be garbage collectable"
+      end
+
+      hash = key.hash
+      @refs[hash] = WeakRef.new(key)
+      @map[hash] = value
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{(object_id << 1).to_s(16).rjust(14, '0')} size=#{@map.size}>"
+    end
+
+    def clear
+      @map.clear
+      @refs.clear
+      self
+    end
+
+    def delete(key, &block)
+      hash = key.hash
+      retval = nil
+
+      if @refs.key?(hash)
+        retval = @map[hash]
+      end
+
+      if block_given?
+        retval = yield key
+      end
+
+      @refs.delete(hash)
+      @map.delete(hash)
+
+      retval
+    end
+
+    def getkey(key)
+      hash = key.hash
+
+      if @refs.key?(hash)
+        ref = @refs[hash]
+
+        begin
+          return ref.__getobj__
+        rescue WeakRef::RefError
+          @refs.delete(hash)
+          @map.delete(hash)
+        end
+      end
+
+      nil
+    end
+
+    def key?(key)
+      hash = key.hash
+
+      if @refs.key?(hash)
+        ref = @refs[hash]
+        return true if ref.weakref_alive?
+
+        @refs.delete(hash)
+        @map.delete(hash)
+      end
+
+      false
+    end
+
+    def size
+      @refs.size
+    end
+
+    alias length size
+  end
+end

data/lib/weak_key_map/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class WeakKeyMap
+  VERSION = "1.0.0"
+end

data/lib/weak_key_map.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+if !ObjectSpace.const_defined?(:WeakKeyMap, false)
+  require_relative "weak_key_map/impl"
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "weak_key_map"
+require "minitest"
+require "minitest/autorun"

data/test/weak_key_map_test.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: false
+
+require_relative "./test_helper"
+require "weak_key_map"
+
+class WeakKeyMapTest < Minitest::Test
+  def setup
+    @wm = ObjectSpace::WeakKeyMap.new
+  end
+
+  def test_map
+    x = Object.new
+    k = "foo"
+    @wm[k] = x
+    assert_same(x, @wm[k])
+    assert_same(x, @wm["FOO".downcase])
+  end
+
+  def test_aset_const
+    x = Object.new
+    assert_raises(ArgumentError) { @wm[true] = x }
+    assert_raises(ArgumentError) { @wm[false] = x }
+    assert_raises(ArgumentError) { @wm[nil] = x }
+    assert_raises(ArgumentError) { @wm[42] = x }
+    assert_raises(ArgumentError) { @wm[2**128] = x }
+    assert_raises(ArgumentError) { @wm[1.23] = x }
+    assert_raises(ArgumentError) { @wm[:foo] = x }
+    assert_raises(ArgumentError) { @wm["foo#{rand}".to_sym] = x }
+  end
+
+  def test_getkey
+    k = "foo"
+    @wm[k] = true
+    assert_same(k, @wm.getkey("FOO".downcase))
+  end
+
+  def test_key?
+    assert_weak_include(:key?, "foo")
+    assert !@wm.key?("bar")
+  end
+
+  def test_delete
+    k1 = "foo"
+    x1 = Object.new
+    @wm[k1] = x1
+    assert_equal x1, @wm[k1]
+    assert_equal x1, @wm.delete(k1)
+    assert_nil @wm[k1]
+    assert_nil @wm.delete(k1)
+
+    fallback = @wm.delete(k1) do |key|
+      assert_equal k1, key
+      42
+    end
+    assert_equal 42, fallback
+  end
+
+  def test_clear
+    k = "foo"
+    @wm[k] = true
+    assert @wm[k]
+    assert_same @wm, @wm.clear
+    refute @wm[k]
+  end
+
+  def test_inspect
+    x = Object.new
+    k = Object.new
+    @wm[k] = x
+    assert_match(/\A\#<#{@wm.class.name}:[\dxa-f]+ size=\d+>\z/, @wm.inspect)
+
+    1000.times do |i|
+      @wm[i.to_s] = Object.new
+      @wm.inspect
+    end
+    assert_match(/\A\#<#{@wm.class.name}:[\dxa-f]+ size=\d+>\z/, @wm.inspect)
+  end
+
+  def test_no_hash_method
+    k = BasicObject.new
+    assert_raises NoMethodError do
+      @wm[k] = 42
+    end
+  end
+
+  def test_frozen_object
+    o = Object.new.freeze
+    @wm[o] = 'foo' # no error raised
+    @wm['foo'] = o  # no error raised
+  end
+
+  private
+
+  def assert_normal_exit(code, message = nil)
+    require "tempfile"
+
+    Tempfile.create(["weak_key_map_test", ".rb"]) do |f|
+      f.write(code)
+      f.flush
+
+      lib_path = File.expand_path("../lib", __dir__)
+      output = `ruby -I#{lib_path} #{f.path} 2>&1`
+      status = $?
+
+      assert status.success?,
+        "Expected script to exit normally but got exit code #{status.exitstatus}.\n" +
+        "Output:\n#{output}" +
+        (message ? "\n#{message}" : "")
+    end
+  end
+
+  def assert_weak_include(m, k, n = 100)
+    if n > 0
+      return assert_weak_include(m, k, n - 1)
+    end
+    1.times do
+      x = Object.new
+      @wm[k] = x
+      assert @wm.send(m, k)
+      assert @wm.send(m, "FOO".downcase)
+      x = Object.new
+    end
+  end
+end

data/weak_key_map.gemspec

@@ -0,0 +1,16 @@
+$:.unshift File.join(File.dirname(__FILE__), "lib")
+require "weak_key_map/version"
+
+Gem::Specification.new do |s|
+  s.name     = "weak_key_map"
+  s.version  = ::WeakKeyMap::VERSION
+  s.authors  = ["Cameron Dutro"]
+  s.email    = ["camertron@gmail.com"]
+  s.homepage = "http://github.com/camertron/weak_key_map"
+  s.description = s.summary = "A backport of ObjectSpace::WeakKeyMap for Ruby < 3.3"
+  s.platform = Gem::Platform::RUBY
+
+  s.require_path = "lib"
+
+  s.files = Dir["{lib,test}/**/*", "Gemfile", "LICENSE", "CHANGELOG.md", "README.md", "Rakefile", "weak_key_map.gemspec"]
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: weak_key_map
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cameron Dutro
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-11-10 00:00:00.000000000 Z
+dependencies: []
+description: A backport of ObjectSpace::WeakKeyMap for Ruby < 3.3
+email:
+- camertron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- lib/weak_key_map.rb
+- lib/weak_key_map/impl.rb
+- lib/weak_key_map/version.rb
+- test/test_helper.rb
+- test/weak_key_map_test.rb
+- weak_key_map.gemspec
+homepage: http://github.com/camertron/weak_key_map
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: A backport of ObjectSpace::WeakKeyMap for Ruby < 3.3
+test_files: []