minitest-memory 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c37208f0d913977a738af1587640fccfef97dfa89cbcde685653b809e42463f0
-  data.tar.gz: 4889e9fa26a92c685079c12af6514d205c0b32c56bcdfdbcebae834f44801c9f
+  metadata.gz: 1e0dd689600ea1bb57af6388a94015c3bf9ec9dcfc737aa26967a822e005cde0
+  data.tar.gz: 1d9059075cd6a38d425cb32adcdac88528dcfa3dcfb4421b21776c94910feee9
 SHA512:
-  metadata.gz: 308e793bd885a60f51b1b756a7520fb38e61a5032eff3db8e8e56ed033b6b1ab12477cafd5e98c899f04ee1bc01fa1dc0950b9fc75219bcfd842a808b3db64f0
-  data.tar.gz: 9b84c7636fb559bcc634b7ed64eb8b58f48dd5ae5283eb991ab9d67f683bd175b8826a7fa604e6c5526f04911bafe4211128867b269b54c4ad3e5e43583e3955
+  metadata.gz: cce664e89b49ec5493d47254b07cdae98eb0496f86fb8795c9eb800ed04953e63455619ed63c5ffdb106985b9915c7851a91b41732038afbf692d21340dc2194
+  data.tar.gz: 74af65dfaf4c69b13c5e10122c497755d3af225e24440192254a0422379f6e9a21666d048675c183e911a3a6ddc738d1051d7e4d5de5ac971b42745770d4e40b

data/CHANGELOG.md

@@ -2,9 +2,19 @@
 
 All notable changes to this project will be documented in this file.
 
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/2.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [1.1.1] - 2026-10-20
+
+### Fixed
+
+- The gem now includes its RBS type signatures (`sig/minitest-memory.rbs`), which were left out of the package
+- Loading on JRuby, whose `objspace` has no `ObjectSpace.memsize_of` (the gem raised `NoMethodError` as it loaded)
+- Where allocations can't be traced (JRuby, TruffleRuby), assertions now run their block (they used to skip it) and then skip the test, instead of failing limits that expect allocations or passing without checking anything
+
 ## [1.1.0] - 2026-03-08
 
 ### Added
@@ -24,3 +34,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - `Minitest::Memory::AllocationCounter.count` — counts object allocations by class within a block
 - `assert_allocations` — fails if any class exceeds its allocation limit within a block
+
+[Unreleased]: https://github.com/sferik/minitest-memory/compare/v1.1.1...HEAD
+[1.1.1]: https://github.com/sferik/minitest-memory/compare/v1.1.0...v1.1.1
+[1.1.0]: https://github.com/sferik/minitest-memory/compare/v1.0.0...v1.1.0
+[1.0.0]: https://github.com/sferik/minitest-memory/releases/tag/v1.0.0

data/README.md

@@ -11,6 +11,16 @@ Add to your Gemfile:
 gem "minitest-memory"
 ```
 
+## Supported Rubies
+
+minitest-memory requires Ruby 3.2 or later. Counting allocations relies on
+CRuby's `ObjectSpace` allocation tracing, so it works only on CRuby.
+
+On JRuby and TruffleRuby, allocations can't be counted. The assertions and
+expectations still run their block, then skip the test, so the test run
+shows that nothing was checked instead of passing. Because a skip ends the
+test, any assertions after it in the same test don't run on those Rubies.
+
 ## Usage
 
 Include `Minitest::Memory` in your test class, then use `assert_allocations`

data/lib/minitest/memory/version.rb

@@ -3,6 +3,6 @@ module Minitest # :nodoc:
   # Version information for minitest-memory.
   module Memory
     # Current version of minitest-memory.
-    VERSION = "1.1.0".freeze
+    VERSION = "1.1.1".freeze
   end
 end

data/lib/minitest/memory.rb

@@ -1,4 +1,10 @@
-require "objspace"
+# :nocov:
+begin
+  require "objspace"
+rescue LoadError
+  # objspace is not available on JRuby
+end
+# :nocov:
 require "minitest/strict"
 require_relative "memory/version"
 
@@ -25,7 +31,14 @@ module Minitest
 
       ##
       # Base memory size of an empty Ruby object slot.
-      SLOT_SIZE = ObjectSpace.memsize_of(Object.new)
+      # :nocov:
+      SLOT_SIZE =
+        if ObjectSpace.respond_to?(:memsize_of)
+          ObjectSpace.memsize_of(Object.new)
+        else
+          0
+        end
+      # :nocov:
 
       empty_sources = {} #: Hash[String, Integer]
 
@@ -38,9 +51,7 @@ module Minitest
       # is not supported, +true+ otherwise.
 
       def self.supported?
-        # :nocov:
-        return false if RUBY_ENGINE == "truffleruby"
-        # :nocov:
+        return false if RUBY_ENGINE == "truffleruby" # simplecov:disable
 
         ObjectSpace.respond_to?(:trace_object_allocations)
       end
@@ -88,9 +99,7 @@ module Minitest
       # running GC to identify retained objects. Returns a Result.
 
       def self.trace(klasses, retain: false, &)
-        # :nocov:
-        return Result.new({}, {}, EMPTY) unless supported?
-        # :nocov:
+        return untraced(&) unless supported?
 
         GC.start
         GC.disable
@@ -103,6 +112,16 @@ module Minitest
       end
       private_class_method :trace
 
+      ##
+      # Runs the block where allocations can't be traced, returning an
+      # empty Result.
+
+      def self.untraced
+        yield # steep:ignore InsufficientPositionalArguments
+        Result.new({}, {}, EMPTY)
+      end
+      private_class_method :untraced
+
       ##
       # Tallies one object's count and byte size into both the
       # +total+ and per-class +bucket+ entries.
@@ -123,9 +142,7 @@ module Minitest
 
       def self.record_source(obj, total, bucket)
         file = ObjectSpace.allocation_sourcefile(obj)
-        # :nocov:
-        return unless file
-        # :nocov:
+        return unless file # simplecov:disable
 
         source = "#{file}:#{ObjectSpace.allocation_sourceline(obj)}"
         total.sources[source] += 1
@@ -177,19 +194,14 @@ module Minitest
     #   assert_allocations(String => 1, count: 10) { "hello" }
 
     def assert_allocations(limits, &)
-      klasses = limits.keys.select { |k| k.is_a?(Module) }
+      skip_untraced(&) unless AllocationCounter.supported?
+
+      klasses = limits.keys.grep(Module)
       has_total_limit = limits.key?(:count) || limits.key?(:size)
       result = AllocationCounter.count(klasses, &)
 
       check_limits(limits, result)
-
-      return if has_total_limit
-
-      result.ignored.each do |klass, alloc|
-        msg = "Allocated #{alloc.count} #{klass} instances, #{alloc.size} bytes, " \
-              "but it was not specified#{format_sources(alloc.sources)}"
-        flunk msg
-      end
+      check_unspecified(result) unless has_total_limit
     end
 
     ##
@@ -205,7 +217,9 @@ module Minitest
     #   assert_retentions(String => {count: 1, size: 1024}) { "hello" }
 
     def assert_retentions(limits, &)
-      klasses = limits.keys.select { |k| k.is_a?(Module) }
+      skip_untraced(&) unless AllocationCounter.supported?
+
+      klasses = limits.keys.grep(Module)
       result = AllocationCounter.count_retained(klasses, &)
 
       check_limits(limits, result, metric: "retentions", size_metric: "retained bytes")
@@ -218,6 +232,8 @@ module Minitest
     #   refute_allocations(String, Array) { 1 + 1 }
 
     def refute_allocations(*classes, &)
+      skip_untraced(&) unless AllocationCounter.supported?
+
       check_zero(AllocationCounter.count(classes, &), classes)
     end
 
@@ -228,6 +244,8 @@ module Minitest
     #   refute_retentions(String, Array) { 1 + 1 }
 
     def refute_retentions(*classes, &)
+      skip_untraced(&) unless AllocationCounter.supported?
+
       check_zero(AllocationCounter.count_retained(classes, &), classes, metric: "retentions")
     end
 
@@ -238,9 +256,7 @@ module Minitest
 
     def self.included(base) # :nodoc:
       super
-      # :nocov:
-      Minitest::Expectation.include(Expectations) if defined?(Minitest::Expectation)
-      # :nocov:
+      Minitest::Expectation.include(Expectations) if defined?(Minitest::Expectation) # simplecov:disable
     end
 
     ##
@@ -287,6 +303,28 @@ module Minitest
 
     private
 
+    ##
+    # Runs the block where allocations can't be traced (JRuby,
+    # TruffleRuby), then skips the test: nothing was checked, so it
+    # shouldn't pass.
+
+    def skip_untraced
+      yield # steep:ignore InsufficientPositionalArguments
+      skip "Allocations can't be traced on #{RUBY_ENGINE}"
+    end
+
+    ##
+    # Fails for allocations of classes +limits+ didn't name (when it set
+    # no total limit).
+
+    def check_unspecified(result)
+      result.ignored.each do |klass, alloc|
+        msg = "Allocated #{alloc.count} #{klass} instances, #{alloc.size} bytes, " \
+              "but it was not specified#{format_sources(alloc.sources)}"
+        flunk msg
+      end
+    end
+
     ##
     # Checks all +limits+ entries against +result+. Routes +:count+
     # and +:size+ to total-limit checks, and Module keys to

data/sig/minitest-memory.rbs

@@ -0,0 +1,128 @@
+module Minitest
+  module Memory
+    VERSION: String
+
+    class AllocationCounter
+      class Allocation < ::Struct[Integer]
+        attr_accessor count: Integer
+        attr_accessor size: Integer
+        attr_accessor sources: Hash[String, Integer]
+
+        def self.new: (Integer count, Integer size, Hash[String, Integer] sources) -> instance
+      end
+
+      class Result < ::Struct[untyped]
+        attr_accessor allocated: Hash[untyped, Allocation]
+        attr_accessor ignored: Hash[untyped, Allocation]
+        attr_accessor total: Allocation
+
+        def self.new: (Hash[untyped, Allocation] allocated, Hash[untyped, Allocation] ignored, Allocation total) -> instance
+      end
+
+      SLOT_SIZE: Integer
+      EMPTY: Allocation
+
+      # Returns false on TruffleRuby, true otherwise.
+      def self.supported?: () -> bool
+
+      # Counts allocations by class within a block.
+      def self.count: (?Array[Module] klasses) { (untyped) -> untyped } -> Result
+
+      # Counts retained allocations by class within a block.
+      def self.count_retained: (?Array[Module] klasses) { (untyped) -> untyped } -> Result
+
+      # Returns a Result of allocations from a given generation.
+      def self.count_allocations: (Integer generation, ?Array[Module] klasses) -> Result
+
+      private
+
+      # Traces object allocations within a block.
+      def self.trace: (Array[Module] klasses, ?retain: bool) { (untyped) -> untyped } -> Result
+
+      # Runs the block where allocations can't be traced; returns an empty Result.
+      def self.untraced: () { (untyped) -> untyped } -> Result
+
+      # Tallies one object's count and byte size into total and bucket.
+      def self.tally: (untyped obj, Allocation total, Allocation bucket) -> void
+
+      # Records the source location of obj into total and bucket source hashes.
+      def self.record_source: (untyped obj, Allocation total, Allocation bucket) -> void
+
+      # Finds or creates the Allocation entry for obj.
+      def self.bucket_for: (untyped obj, Array[Module] klasses, Hash[untyped, Allocation] allocated, Hash[untyped, Allocation] ignored) -> Allocation
+
+      # Creates a new zeroed Allocation with a default-value sources hash.
+      def self.new_allocation: () -> Allocation
+    end
+
+    include Minitest::Assertions
+
+    type allocation_count_limit = Integer | Range[Integer]
+    type allocation_limit = allocation_count_limit | Hash[Symbol, allocation_count_limit]
+
+    # Includes Expectations into Minitest::Expectation when minitest/spec is loaded.
+    def self.included: (Module base) -> void
+
+    # Fails if any class in limits exceeds its allocation limit.
+    def assert_allocations: (Hash[untyped, allocation_limit] limits) { (untyped) -> untyped } -> void
+
+    # Fails if any class in limits exceeds its retention limit.
+    def assert_retentions: (Hash[untyped, allocation_limit] limits) { (untyped) -> untyped } -> void
+
+    # Fails if any of the given classes are allocated within a block.
+    def refute_allocations: (*Class classes) { (untyped) -> untyped } -> void
+
+    # Fails if any of the given classes are retained within a block.
+    def refute_retentions: (*Class classes) { (untyped) -> untyped } -> void
+
+    # Minitest::Spec expectations for memory allocation assertions.
+    module Expectations
+      # The test context from Minitest::Expectation.
+      def ctx: () -> untyped
+
+      # The target value or block from Minitest::Expectation.
+      def target: () -> untyped
+
+      # See Minitest::Memory#assert_allocations.
+      def must_limit_allocations: (Hash[untyped, allocation_limit] limits) -> void
+
+      # See Minitest::Memory#assert_retentions.
+      def must_limit_retentions: (Hash[untyped, allocation_limit] limits) -> void
+
+      # See Minitest::Memory#refute_allocations.
+      def wont_allocate: (*Class classes) -> void
+
+      # See Minitest::Memory#refute_retentions.
+      def wont_retain: (*Class classes) -> void
+    end
+
+    private
+
+    # Runs the block where allocations can't be traced, then skips the test.
+    def skip_untraced: () { (untyped) -> untyped } -> bot
+
+    # Fails for allocations of classes the limits didn't name.
+    def check_unspecified: (AllocationCounter::Result result) -> void
+
+    # Checks all limits entries against result.
+    def check_limits: (Hash[untyped, allocation_limit] limits, AllocationCounter::Result result, ?metric: String, ?size_metric: String) -> void
+
+    # Dispatches a single limit entry for the given klass against the result.
+    def check_limit_entry: (untyped klass, allocation_limit limit, AllocationCounter::Result result, metric: String, size_metric: String) -> void
+
+    # Checks a total :count or :size limit against the aggregate total allocation.
+    def check_total_limit: (:count | :size klass, allocation_count_limit limit, AllocationCounter::Allocation total, size_metric: String) -> void
+
+    # Checks per-class limit against allocation for the given klass.
+    def check_class_limit: (untyped klass, AllocationCounter::Allocation allocation, allocation_limit limit, metric: String, size_metric: String) -> void
+
+    # Asserts that actual falls within limit for the given klass and metric.
+    def check_limit: (untyped klass, allocation_count_limit limit, Integer actual, ?metric: String, sources: Hash[String, Integer]) -> void
+
+    # Asserts zero allocations for each class in classes.
+    def check_zero: (AllocationCounter::Result result, Array[Class] classes, ?metric: String) -> void
+
+    # Formats allocation sources as a newline-separated list of source locations.
+    def format_sources: (Hash[String, Integer] sources) -> String
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-memory
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Erik Berlin
@@ -43,8 +43,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
-description: Provides assert_allocations to verify object allocation counts within
-  a block.
+description: Assertions and expectations that limit the objects a block allocates
+  or retains, by count and size, with the source location of each allocation in failure
+  messages.
 email:
 - sferik@gmail.com
 executables: []
@@ -56,6 +57,7 @@ files:
 - README.md
 - lib/minitest/memory.rb
 - lib/minitest/memory/version.rb
+- sig/minitest-memory.rbs
 homepage: https://sferik.github.io/minitest-memory
 licenses:
 - MIT
@@ -79,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.7
+rubygems_version: 4.0.23
 specification_version: 4
 summary: Memory allocation assertions for Minitest
 test_files: []