Handle recursive data structures

When inspecting or diffing a data structure that refers to itself,
replace that data structure with "∙∙∙" to prevent infinite recursion.

Author: mcmire

README.md

@@ -174,6 +174,24 @@ JRuby >= 9.2.x.
 
 [travis]: http://travis-ci.org/mcmire/super_diff
 
+## Inspiration/Thanks
+
+In developing this gem I made use of or was heavily inspired by these libraries:
+
+* [Diff::LCS][diff-lcs], the library I started with in the [original version of
+  this gem][original-version] (made in 2011!)
+* The pretty-printing algorithms and API within [PrettyPrinter][pretty-printer]
+  and [AwesomePrint][awesome-print], from which I borrowed ideas to develop
+  the [inspectors][inspection-tree].
+
+Thank you so much!
+
+[original-version]: https://github.com/mcmire/super_diff/tree/old-master
+[diff-lcs]: https://github.com/halostatue/diff-lcs
+[pretty-printer]: https://github.com/ruby/ruby/tree/master/lib
+[awesome-print]: https://github.com/awesome-print/awesome_print
+[inspection-tree]: https://github.com/mcmire/super_diff/blob/master/lib/super_diff/object_inspection/inspection_tree.rb
+
 ## Copyright/License
 
 © 2018-2019 Elliot Winkler, released under the [MIT license](LICENSE).

lib/super_diff.rb

@@ -22,4 +22,5 @@ module SuperDiff
   autoload :OperationalSequencers, "super_diff/operational_sequencers"
   autoload :OperationSequences, "super_diff/operation_sequences"
   autoload :Operations, "super_diff/operations"
+  autoload :RecursionGuard, "super_diff/recursion_guard"
 end

lib/super_diff/diff_formatters/collection.rb

@@ -37,36 +37,72 @@ def lines
       def contents
         operations.map do |operation|
           if operation.name == :change
+            handle_change_operation(operation)
+          else
+            handle_non_change_operation(operation)
+          end
+        end
+      end
+
+      def handle_change_operation(operation)
+        SuperDiff::RecursionGuard.guarding_recursion_of(
+          operation.left_collection,
+          operation.right_collection,
+        ) do |already_seen|
+          if already_seen
+            raise "Infinite recursion!"
+          else
             operation.child_operations.to_diff(
               indent_level: indent_level + 1,
               collection_prefix: build_item_prefix.call(operation),
               add_comma: operation.should_add_comma_after_displaying?,
             )
-          else
-            icon = ICONS.fetch(operation.name, " ")
-            style_name = STYLES.fetch(operation.name, :normal)
-            chunk = build_chunk(
-              operation.value,
-              prefix: build_item_prefix.call(operation),
-              icon: icon,
-            )
+          end
+        end
+      end
 
-            if operation.should_add_comma_after_displaying?
-              chunk << ","
-            end
+      def handle_non_change_operation(operation)
+        icon = ICONS.fetch(operation.name, " ")
+        style_name = STYLES.fetch(operation.name, :normal)
+        chunk = build_chunk_for(
+          operation,
+          prefix: build_item_prefix.call(operation),
+          icon: icon,
+        )
 
-            style_chunk(style_name, chunk)
-          end
+        if operation.should_add_comma_after_displaying?
+          chunk << ","
         end
+
+        style_chunk(style_name, chunk)
       end
 
-      def build_chunk(value, prefix:, icon:)
+      def build_chunk_for(operation, prefix:, icon:)
+        if operation.value.equal?(operation.collection)
+          build_chunk_from_string(
+            SuperDiff::RecursionGuard::PLACEHOLDER,
+            prefix: build_item_prefix.call(operation),
+            icon: icon,
+          )
+        else
+          build_chunk_by_inspecting(
+            operation.value,
+            prefix: build_item_prefix.call(operation),
+            icon: icon,
+          )
+        end
+      end
+
+      def build_chunk_by_inspecting(value, prefix:, icon:)
         inspection = ObjectInspection.inspect(
           value,
           as_single_line: false,
         )
+        build_chunk_from_string(inspection, prefix: prefix, icon: icon)
+      end
 
-        inspection.split("\n").
+      def build_chunk_from_string(value, prefix:, icon:)
+        value.split("\n").
           map.with_index { |line, index|
             [
               icon,

lib/super_diff/object_inspection.rb

@@ -1,6 +1,7 @@
 module SuperDiff
   module ObjectInspection
     autoload :InspectionTree, "super_diff/object_inspection/inspection_tree"
+    autoload :Inspector, "super_diff/object_inspection/inspector"
     autoload :Inspectors, "super_diff/object_inspection/inspectors"
     autoload :Map, "super_diff/object_inspection/map"
     autoload :Nodes, "super_diff/object_inspection/nodes"
@@ -10,7 +11,8 @@ class << self
     end
 
     def self.inspect(object, as_single_line:, indent_level: 0)
-      map.call(object).evaluate(
+      Inspector.call(
+        map,
         object,
         as_single_line: as_single_line,
         indent_level: indent_level,

lib/super_diff/object_inspection/inspector.rb

@@ -0,0 +1,27 @@
+module SuperDiff
+  module ObjectInspection
+    class Inspector
+      extend AttrExtras.mixin
+
+      method_object :map, :object, [:indent_level!, :as_single_line!]
+
+      def call
+        SuperDiff::RecursionGuard.substituting_recursion_of(object) do
+          inspector.evaluate(
+            object,
+            as_single_line: as_single_line,
+            indent_level: indent_level,
+          )
+        end
+      end
+
+      private
+
+      attr_query :as_single_line?
+
+      def inspector
+        @_inspector ||= map.call(object)
+      end
+    end
+  end
+end

lib/super_diff/operational_sequencers/array.rb

@@ -19,6 +19,7 @@ def lcs_callbacks
           actual: actual,
           extra_operational_sequencer_classes: extra_operational_sequencer_classes,
           extra_diff_formatter_classes: extra_diff_formatter_classes,
+          sequence: method(:sequence),
         )
       end
 
@@ -36,6 +37,7 @@ class LcsCallbacks
             :actual!,
             :extra_operational_sequencer_classes!,
             :extra_diff_formatter_classes!,
+            :sequence!
           ],
         )
         public :operations
@@ -74,7 +76,7 @@ def discard_b(event)
         end
 
         def change(event)
-          child_operations = sequence(event.old_element, event.new_element)
+          child_operations = sequence.call(event.old_element, event.new_element)
 
           if child_operations
             add_change_operation(event, child_operations)
@@ -86,16 +88,6 @@ def change(event)
 
         private
 
-        def sequence(expected, actual)
-          OperationalSequencer.call(
-            expected: expected,
-            actual: actual,
-            all_or_nothing: false,
-            extra_classes: extra_operational_sequencer_classes,
-            extra_diff_formatter_classes: extra_diff_formatter_classes,
-          )
-        end
-
         def add_change_operation(event, child_operations)
           operations << ::SuperDiff::Operations::BinaryOperation.new(
             name: :change,

lib/super_diff/operational_sequencers/base.rb

@@ -62,7 +62,9 @@ def build_operation_sequencer
 
       def possible_comparison_of(operation, next_operation)
         if should_compare?(operation, next_operation)
-          sequence(operation, next_operation)
+          sequence(operation.value, next_operation.value)
+        else
+          nil
         end
       end
 
@@ -73,10 +75,10 @@ def should_compare?(operation, next_operation)
           next_operation.index == operation.index
       end
 
-      def sequence(operation, next_operation)
+      def sequence(expected, actual)
         OperationalSequencer.call(
-          expected: operation.value,
-          actual: next_operation.value,
+          expected: expected,
+          actual: actual,
           all_or_nothing: false,
           extra_classes: extra_operational_sequencer_classes,
           extra_diff_formatter_classes: extra_diff_formatter_classes,

lib/super_diff/recursion_guard.rb

@@ -0,0 +1,47 @@
+module SuperDiff
+  module RecursionGuard
+    RECURSION_GUARD_KEY = "super_diff_recursion_guard_key".freeze
+    PLACEHOLDER = "∙∙∙".freeze
+
+    def self.guarding_recursion_of(*objects, &block)
+      already_seen_objects, first_seen_objects = objects.partition do |object|
+        already_seen_object_ids.include?(object.object_id)
+      end
+
+      first_seen_objects.each do |object|
+        already_seen_object_ids.add(object.object_id)
+      end
+
+      result =
+        if block.arity > 0
+          block.call(already_seen_objects.any?)
+        else
+          block.call
+        end
+
+      first_seen_objects.each do |object|
+        already_seen_object_ids.delete(object.object_id)
+      end
+
+      result
+    end
+
+    def self.substituting_recursion_of(*objects)
+      guarding_recursion_of(*objects) do |already_seen|
+        if already_seen
+          PLACEHOLDER
+        else
+          yield
+        end
+      end
+    end
+
+    def self.already_seen_objects
+      already_seen_object_ids.map { |object_id| ObjectSpace._id2ref(object_id) }
+    end
+
+    def self.already_seen_object_ids
+      Thread.current[RECURSION_GUARD_KEY] ||= Set.new
+    end
+  end
+end