Explicit ignore: and seen: options.

Author: ioquatix

lib/memory/usage.rb

@@ -39,22 +39,36 @@ def << allocation
 			return self
 		end
 
+		IGNORE = [
+			# Skip modules and symbols, they are usually "global":
+			Module,
+			# Note that `reachable_objects_from` does not include symbols, numbers, or other value types, AFAICT.
+			
+			Proc,
+			Method,
+			UnboundMethod,
+			Binding,
+			TracePoint,
+			
+			# We don't want to traverse into shared state:
+			Ractor,
+			Thread,
+			Fiber
+		]
+		
 		# Compute the usage of an object and all reachable objects from it.
 		# @parameter root [Object] The root object to start traversal from.
 		# @returns [Usage] The usage of the object and all reachable objects from it.
-		def self.of(root)
-			seen = Set.new.compare_by_identity
-			
+		def self.of(root, seen: Set.new.compare_by_identity, ignore: IGNORE)
 			count = 0
 			size = 0
 
 			queue = [root]
 			while queue.any?
 				object = queue.shift
 
-				# Skip modules and symbols, they are usually "global":
-				next if object.is_a?(Module)
-				# Note that `reachable_objects_from` does not include symbols, numbers, or other value types, AFAICT.
+				# Skip ignored types:
+				next if ignore.any?{|type| object.is_a?(type)}
 
 				# Skip internal objects - they don't behave correctly when added to `seen` and create unbounded recursion:
 				next if object.is_a?(ObjectSpace::InternalObjectWrapper)

releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## Unreleased
+
+  - Explicit `ignore:` and `seen:` parameters for `Memory::Usage.of` to allow customization of ignored types and tracking of seen objects.
+
 ## v0.8.4
 
   - Fix bugs when printing reports due to interface mismatch with `Memory::Usage`.

test/memory/usage.rb

@@ -132,16 +132,18 @@
 			)
 		end
 
-		it "can compute usage of proc" do
-			proc = Proc.new{|x| x * 2}
-			usage = subject.of(proc)
-			expect(usage).to have_attributes(
-				count: be > 1,
-				size: be > 0
-			)
-		end
-		
-		it "can compute usage of nil" do
+	it "can compute usage of proc" do
+		proc = Proc.new{|x| x * 2}
+		# Proc is in default IGNORE list, so we need a custom ignore that allows Proc
+		# but still includes Module to prevent deep traversal
+		usage = subject.of(proc, ignore: [Module])
+		expect(usage).to have_attributes(
+			count: be > 1,
+			size: be > 0
+		)
+	end
+	
+	it "can compute usage of nil" do
 			usage = subject.of(nil)
 			expect(usage).to have_attributes(
 				count: be == 0,
@@ -156,6 +158,213 @@
 				size: be == 0
 			)
 		end
+		
+		with "seen parameter" do
+			it "allows sharing seen set across multiple calls" do
+				# Create a shared seen set
+				seen = Set.new.compare_by_identity
+				
+				shared_object = Object.new
+				array1 = [shared_object]
+				array2 = [shared_object]
+				
+				# First call tracks the array and shared object
+				usage1 = subject.of(array1, seen: seen)
+				expect(usage1.count).to be == 2  # array1 + shared_object
+				
+				# Second call should skip shared_object since it's already in seen
+				usage2 = subject.of(array2, seen: seen)
+				expect(usage2.count).to be == 1  # Only array2, shared_object already seen
+			end
+			
+			it "respects pre-populated seen set" do
+				seen = Set.new.compare_by_identity
+				
+				existing_object = Object.new
+				seen.add(existing_object)
+				
+				array = [existing_object, Object.new]
+				usage = subject.of(array, seen: seen)
+				
+				# Should count array + new object, but not existing_object
+				expect(usage.count).to be == 2
+			end
+			
+			it "updates seen set during traversal" do
+				seen = Set.new.compare_by_identity
+				
+				object = [Object.new, Object.new]
+				usage = subject.of(object, seen: seen)
+				
+				# All 3 objects should now be in seen
+				expect(seen.size).to be == 3
+			end
+			
+			it "prevents counting same object graph twice" do
+				seen = Set.new.compare_by_identity
+				
+				root = {data: [1, 2, 3]}
+				
+				# First traversal
+				usage1 = subject.of(root, seen: seen)
+				first_count = usage1.count
+				
+				# Second traversal with same seen set should find nothing new
+				usage2 = subject.of(root, seen: seen)
+				expect(usage2.count).to be == 0
+			end
+		end
+		
+		with "ignore parameter" do
+			it "skips specified types from traversal" do
+				# Create a custom ignore list that includes String
+				custom_ignore = [Module, String]
+				
+				array = [Object.new, "ignored string", Object.new]
+				usage = subject.of(array, ignore: custom_ignore)
+				
+				# Should count array + 2 objects, but not the string
+				expect(usage.count).to be == 3
+			end
+			
+			it "uses default IGNORE constant when not specified" do
+				# Test that Module is ignored by default
+				object = [Object.new, String]
+				usage = subject.of(object)
+				
+				expect(usage.count).to be == 2 # array + object, not String (Module).
+			end
+			
+			it "can provide different ignore list" do
+				# Provide an ignore list that doesn't include String
+				# (but still includes Module to avoid deep traversal)
+				custom_ignore = [Module]
+				
+				string = "test string"
+				object = [string]
+				
+				usage_with_default = subject.of(object)
+				usage_with_custom = subject.of(object, ignore: custom_ignore)
+				
+				# Both should count the array and string (String class is a Module, but string instances aren't)
+				expect(usage_with_default.count).to be == 2
+				expect(usage_with_custom.count).to be == 2
+			end
+			
+			it "ignores Proc by default" do
+				proc = Proc.new { "test" }
+				array = [proc]
+				usage = subject.of(array)
+				
+				# Should count only the array, not the Proc
+				expect(usage.count).to be == 1
+			end
+			
+			it "ignores Thread by default" do
+				thread = Thread.current
+				array = [thread]
+				usage = subject.of(array)
+				
+				# Should count only the array, not the Thread
+				expect(usage.count).to be == 1
+			end
+			
+			it "ignores Fiber by default" do
+				fiber = Fiber.new { "test" }
+				array = [fiber]
+				usage = subject.of(array)
+				
+				# Should count only the array, not the Fiber
+				expect(usage.count).to be == 1
+			end
+			
+			it "ignores Method by default" do
+				method = Object.new.method(:to_s)
+				array = [method]
+				usage = subject.of(array)
+				
+				# Should count only the array, not the Method
+				expect(usage.count).to be == 1
+			end
+			
+			it "can override ignore list to include custom types" do
+				# Define a custom class
+				custom_class = Class.new
+				instance = custom_class.new
+				
+				# Create ignore list that includes our custom class
+				custom_ignore = [Module, custom_class]
+				
+				array = [instance, Object.new]
+				usage = subject.of(array, ignore: custom_ignore)
+				
+				# Should count array + Object, but not custom_class instance
+				expect(usage.count).to be == 2
+			end
+			
+			it "checks ignore list with is_a? for inheritance" do
+				# Create a subclass
+				parent_class = Class.new
+				child_class = Class.new(parent_class)
+				
+				parent_instance = parent_class.new
+				child_instance = child_class.new
+				
+				# Ignore parent class
+				custom_ignore = [Module, parent_class]
+				
+				array = [parent_instance, child_instance]
+				usage = subject.of(array, ignore: custom_ignore)
+				
+				# Both instances should be ignored (child is_a? parent)
+				expect(usage.count).to be == 1  # Only the array
+			end
+		end
+		
+		with "combined seen and ignore parameters" do
+			it "applies both seen and ignore filters" do
+				seen = Set.new.compare_by_identity
+				existing = Object.new
+				seen.add(existing)
+				
+				custom_ignore = [Module, String]
+				
+				array = [existing, "ignored", Object.new]
+				usage = subject.of(array, seen: seen, ignore: custom_ignore)
+				
+				# Should count array + new object only
+				# (existing is in seen, string is in ignore)
+				expect(usage.count).to be == 2
+			end
+			
+			it "checks ignore before adding to seen" do
+				seen = Set.new.compare_by_identity
+				custom_ignore = [Module, String]
+				
+				array = ["ignored string"]
+				usage = subject.of(array, seen: seen, ignore: custom_ignore)
+				
+				# String should not be added to seen since it's ignored
+				expect(seen.size).to be == 1  # Only array
+				expect(seen).not.to be(:include?, "ignored string")
+			end
+			
+			it "preserves seen across multiple calls with different ignore lists" do
+				seen = Set.new.compare_by_identity
+				
+				# First call with default ignore
+				obj1 = [Object.new]
+				usage1 = subject.of(obj1, seen: seen)
+				count1 = seen.size
+				
+				# Second call with custom ignore
+				obj2 = [Object.new, "test"]
+				usage2 = subject.of(obj2, seen: seen, ignore: [Module])
+				
+				# Seen should have accumulated objects from both calls
+				expect(seen.size).to be > count1
+			end
+		end
 	end
 
 	with "#to_s" do