foobara-util 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18c1181684054682ef921400e25c976d94c10f64dff2c036ebe9ba7b08cf09d5
-  data.tar.gz: a91bb09d64d336e9c46bbfa20746da5abbedcb4fa4fa93f3ade09876ddaa6692
+  metadata.gz: dfa3f65a13306f37f57d39d0bcf7cbebc98cb9e580c6ee8b562744f5cb3091f9
+  data.tar.gz: 5e9e6cb4a398fbcd9386a79932e30a5d0d4f1c48cbf228cca0189b29c17c5d8b
 SHA512:
-  metadata.gz: 5a387cf68464f15054d99112d0b89f64f2516581c207e0587f8dbe5ff5a788144e6798860ea36a942889dab2dbdd0e1fe1aea6657f12d0f3d883a9c06460a857
-  data.tar.gz: fb8471223c146c78e749697001a5edf034c37ac0e3f28d8bdca07f1dcd565546d2bff9cbb5d552027d1d177f1d2b24aee6daa9439a97bca647e381864c824d60
+  metadata.gz: d2f56dd4ca2a33e244375c12aa9b2a2e09e8e78c1c5102123f2897340333cd7b8934dd12a0fe9e6722ba110f331154a2169c8e7417cde5fcc1791b78cfc9e2d4
+  data.tar.gz: a68d604c7e20ca081fb67ae1208fe2b22b6de28146b8f9685678dc0ddb6e8b04d30761769b284f16aceca262cff4323f78b8a077e35d98c40c93a25ad31ad192

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [1.0.4] - 2025-11-01
+
+- Add .referencing_paths to help debugging finding what object is referencing another
+
 ## [1.0.3] - 2025-09-21
 
 - Fix bug that gives non-deterministic load order for file names that have the same depth and length

data/lib/foobara/util/object_space.rb

@@ -0,0 +1,193 @@
+module Foobara
+  module Util
+    class ReferencePathPart
+      attr_accessor :referencer, :referencee, :via, :via_type
+
+      def initialize(referencer, referencee, via, via_type)
+        self.referencer = referencer
+        self.referencee = referencee
+        self.via = via
+        self.via_type = via_type
+      end
+    end
+
+    class << self
+      def object_id_to_object(object_id)
+        ObjectSpace._id2ref(object_id)
+      rescue RangeError
+        nil
+      end
+
+      def referencing_paths(object)
+        paths = _referencing_paths(object.object_id, object_id_referenced_by_map)
+        paths.sort_by!(&:size)
+        paths.reverse!
+        paths
+      end
+
+      private
+
+      def _referencing_paths(object_id, map, seen = Set.new, parts = [], paths = [])
+        seen << object_id
+
+        path_parts = map[object_id]&.uniq&.reject do |path_part|
+          seen.include?(path_part.referencer)
+        end&.uniq
+
+        if path_parts && !path_parts.empty?
+          path_parts.each do |path_part|
+            _referencing_paths(path_part.referencer, map, seen, [*parts, path_part], paths)
+          end
+        else
+          resolved_parts = []
+
+          parts.each do |part|
+            referenced_by = object_id_to_object(part.referencer)
+
+            via = part.via
+
+            via = case part.via_type
+                  when :constant
+                    "::#{via}"
+                  when :array_index, :hash_value
+                    "[#{via.inspect}]"
+                  when :hash_key
+                    "{#{via}}"
+                  when :ivar
+                    via
+                  else
+                    # :nocov:
+                    raise "Unexpected via_type #{part.via_type}"
+                    # :nocov:
+                  end
+
+            class_part = if referenced_by.is_a?(Module)
+                           name = referenced_by.name
+
+                           if name
+                             name
+                           elsif referenced_by.is_a?(Class)
+                             "AnonClass:#{referenced_by.object_id}"
+                           else
+                             "AnonModule:#{referenced_by.object_id}"
+                           end
+                         else
+                           "<#{referenced_by.class}:#{referenced_by.object_id}>"
+                         end
+
+            resolved_parts << "#{class_part}#{via}"
+          end
+
+          resolved_parts.reverse!
+
+          paths << resolved_parts
+        end
+
+        paths
+      end
+
+      def all_objects
+        ObjectSpace.each_object.to_a
+      end
+
+      UNINTERESTING_REFERENCE_CLASSES = [
+        "String",
+        "Proc",
+        "Time",
+        "Regexp",
+        "WeakRef",
+        "Thread::Mutex",
+        "Gem::Requirement",
+        "Symbol"
+      ].freeze
+
+      private_constant :UNINTERESTING_REFERENCE_CLASSES
+
+      def object_id_references_map
+        references = {}
+
+        objects = all_objects
+
+        uninteresting_classes = UNINTERESTING_REFERENCE_CLASSES.map do |class_name|
+          if Object.const_defined?(class_name)
+            Object.const_get(class_name)
+          end
+        end.compact
+
+        objects = objects.reject do |object|
+          uninteresting_classes.include?(object.class)
+        end
+
+        objects.each do |object|
+          # rubocop:disable Lint/HashCompareByIdentity
+          references[object.object_id] = object_id_references(object)
+          # rubocop:enable Lint/HashCompareByIdentity
+        end
+
+        references
+      end
+
+      def object_id_referenced_by_map
+        referenced_by = {}
+
+        object_id_references_map.each_value do |references|
+          references.each do |referenced_path_part|
+            referenced_object_id = referenced_path_part.referencee
+
+            referenced_by[referenced_object_id] ||= []
+            referenced_by[referenced_object_id] << referenced_path_part
+          end
+        end
+
+        referenced_by
+      end
+
+      def object_id_references(object)
+        object_id = object.object_id
+
+        references = object.instance_variables.map do |ivar|
+          ReferencePathPart.new(
+            object_id,
+            object.instance_variable_get(ivar).object_id,
+            ivar,
+            :ivar
+          )
+        end
+
+        case object
+        when ::Module
+          object.constants(false).each do |constant_name|
+            references << ReferencePathPart.new(
+              object_id,
+              object.const_get(constant_name).object_id,
+              constant_name,
+              :constant
+            )
+            # rubocop:disable Lint/RescueException
+          rescue Exception
+            # rubocop:enable Lint/RescueException
+            nil
+          end
+        when ::Array, ::Set
+
+          object.each.with_index do |element, index|
+            references << ReferencePathPart.new(
+              object_id,
+              element.object_id,
+              index,
+              :array_index
+            )
+          end
+
+        when ::Hash
+          object.each_pair do |k, v|
+            references << ReferencePathPart.new(object_id, k.object_id, k, :hash_key)
+            references << ReferencePathPart.new(object_id, v.object_id, k, :hash_value)
+          end
+        end
+
+        references
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-util
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Miles Georgi
@@ -28,6 +28,7 @@ files:
 - lib/foobara/util/hash.rb
 - lib/foobara/util/meta.rb
 - lib/foobara/util/module.rb
+- lib/foobara/util/object_space.rb
 - lib/foobara/util/require.rb
 - lib/foobara/util/string.rb
 - lib/foobara/util/structured.rb