super_diff 0.11.0 → 0.12.1

data/lib/super_diff/core/inspection_tree_nodes.rb

@@ -0,0 +1,55 @@
+module SuperDiff
+  module Core
+    module InspectionTreeNodes
+      autoload(
+        :AsLinesWhenRenderingToLines,
+        "super_diff/core/inspection_tree_nodes/as_lines_when_rendering_to_lines"
+      )
+      autoload(
+        :AsPrefixWhenRenderingToLines,
+        "super_diff/core/inspection_tree_nodes/as_prefix_when_rendering_to_lines"
+      )
+      autoload(
+        :AsPreludeWhenRenderingToLines,
+        "super_diff/core/inspection_tree_nodes/as_prelude_when_rendering_to_lines"
+      )
+      autoload(
+        :AsSingleLine,
+        "super_diff/core/inspection_tree_nodes/as_single_line"
+      )
+      autoload :Base, "super_diff/core/inspection_tree_nodes/base"
+      autoload :Inspection, "super_diff/core/inspection_tree_nodes/inspection"
+      autoload :Nesting, "super_diff/core/inspection_tree_nodes/nesting"
+      autoload :OnlyWhen, "super_diff/core/inspection_tree_nodes/only_when"
+      autoload :Text, "super_diff/core/inspection_tree_nodes/text"
+      autoload :WhenEmpty, "super_diff/core/inspection_tree_nodes/when_empty"
+      autoload(
+        :WhenNonEmpty,
+        "super_diff/core/inspection_tree_nodes/when_non_empty"
+      )
+      autoload(
+        :WhenRenderingToLines,
+        "super_diff/core/inspection_tree_nodes/when_rendering_to_lines"
+      )
+      autoload(
+        :WhenRenderingToString,
+        "super_diff/core/inspection_tree_nodes/when_rendering_to_string"
+      )
+
+      def self.registry
+        @_registry ||= [
+          AsLinesWhenRenderingToLines,
+          AsPrefixWhenRenderingToLines,
+          AsPreludeWhenRenderingToLines,
+          AsSingleLine,
+          Inspection,
+          Nesting,
+          OnlyWhen,
+          Text,
+          WhenRenderingToLines,
+          WhenRenderingToString
+        ]
+      end
+    end
+  end
+end

data/lib/super_diff/core/line.rb

@@ -0,0 +1,85 @@
+module SuperDiff
+  module Core
+    class Line
+      extend AttrExtras.mixin
+
+      ICONS = { delete: "-", insert: "+", noop: " " }.freeze
+      COLORS = { insert: :actual, delete: :expected, noop: :plain }.freeze
+
+      rattr_initialize(
+        [
+          :type!,
+          :indentation_level!,
+          :value!,
+          prefix: "",
+          add_comma: false,
+          children: [],
+          elided: false,
+          collection_bookend: nil,
+          complete_bookend: nil
+        ]
+      )
+      attr_query :add_comma?
+      attr_query :elided?
+
+      def clone_with(overrides = {})
+        self.class.new(
+          type: type,
+          indentation_level: indentation_level,
+          prefix: prefix,
+          value: value,
+          add_comma: add_comma?,
+          children: children,
+          elided: elided?,
+          collection_bookend: collection_bookend,
+          complete_bookend: complete_bookend,
+          **overrides
+        )
+      end
+
+      def icon
+        ICONS.fetch(type)
+      end
+
+      def color
+        COLORS.fetch(type)
+      end
+
+      def with_comma
+        clone_with(add_comma: true)
+      end
+
+      def as_elided
+        clone_with(elided: true)
+      end
+
+      def with_value_prepended(prelude)
+        clone_with(value: prelude + value)
+      end
+
+      def with_value_appended(suffix)
+        clone_with(value: value + suffix)
+      end
+
+      def prefixed_with(prefix)
+        clone_with(prefix: prefix + self.prefix)
+      end
+
+      def with_complete_bookend(complete_bookend)
+        clone_with(complete_bookend: complete_bookend)
+      end
+
+      def opens_collection?
+        collection_bookend == :open
+      end
+
+      def closes_collection?
+        collection_bookend == :close
+      end
+
+      def complete_bookend?
+        complete_bookend != nil
+      end
+    end
+  end
+end

data/lib/super_diff/{errors → core}/no_differ_available_error.rb

@@ -1,5 +1,5 @@
 module SuperDiff
-  module Errors
+  module Core
     class NoDifferAvailableError < StandardError
       def self.create(expected, actual)
         allocate.tap do |error|

data/lib/super_diff/core/no_inspection_tree_builder_available_error.rb

@@ -0,0 +1,21 @@
+module SuperDiff
+  module Core
+    class NoInspectionTreeBuilderAvailableError < StandardError
+      def self.create(object)
+        allocate.tap do |error|
+          error.object = object
+          error.__send__(:initialize)
+        end
+      end
+
+      attr_accessor :object
+
+      def initialize
+        super(<<-MESSAGE)
+There is no inspection tree builder available to handle a "value" of type
+#{object.class}.
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/super_diff/core/no_operation_tree_available_error.rb

@@ -0,0 +1,20 @@
+module SuperDiff
+  module Core
+    class NoOperationTreeAvailableError < StandardError
+      def self.create(value)
+        allocate.tap do |error|
+          error.value = value
+          error.__send__(:initialize)
+        end
+      end
+
+      attr_accessor :value
+
+      def initialize
+        super(<<-MESSAGE)
+There is no operation tree available to handle a "value" of type #{value.class}.
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/super_diff/core/no_operation_tree_builder_available_error.rb

@@ -0,0 +1,24 @@
+module SuperDiff
+  module Core
+    class NoOperationTreeBuilderAvailableError < StandardError
+      def self.create(expected, actual)
+        allocate.tap do |error|
+          error.expected = expected
+          error.actual = actual
+          error.__send__(:initialize)
+        end
+      end
+
+      attr_accessor :expected, :actual
+
+      def initialize
+        super(<<-MESSAGE)
+There is no operation tree builder available to handle an "expected" value of type
+#{expected.class}
+and an "actual" value of type
+#{actual.class}.
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/super_diff/{operation_tree_builders/main.rb → core/operation_tree_builder_dispatcher.rb}

@@ -1,14 +1,18 @@
 module SuperDiff
-  module OperationTreeBuilders
-    class Main
+  module Core
+    class OperationTreeBuilderDispatcher
       extend AttrExtras.mixin
 
-      method_object %i[expected! actual! all_or_nothing!]
+      method_object(
+        :expected,
+        :actual,
+        [:available_classes, raise_if_nothing_applies: true]
+      )
 
       def call
         if resolved_class
           resolved_class.call(expected: expected, actual: actual)
-        elsif all_or_nothing?
+        elsif raise_if_nothing_applies?
           raise NoOperationTreeBuilderAvailableError.create(expected, actual)
         else
           nil
@@ -17,19 +21,11 @@ module SuperDiff
 
       private
 
-      attr_query :all_or_nothing?
+      attr_query :raise_if_nothing_applies?
 
       def resolved_class
         available_classes.find { |klass| klass.applies_to?(expected, actual) }
       end
-
-      def available_classes
-        classes =
-          SuperDiff.configuration.extra_operation_tree_builder_classes +
-            DEFAULTS
-
-        all_or_nothing? ? classes + [DefaultObject] : classes
-      end
     end
   end
 end

data/lib/super_diff/core/operation_tree_finder.rb

@@ -0,0 +1,27 @@
+module SuperDiff
+  module Core
+    class OperationTreeFinder
+      extend AttrExtras.mixin
+
+      method_object :value, [:available_classes]
+
+      def call
+        if resolved_class
+          begin
+            resolved_class.new([], underlying_object: value)
+          rescue ArgumentError
+            resolved_class.new([])
+          end
+        else
+          raise NoOperationTreeAvailableError.create(value)
+        end
+      end
+
+      private
+
+      def resolved_class
+        available_classes.find { |klass| klass.applies_to?(value) }
+      end
+    end
+  end
+end

data/lib/super_diff/core/prefix_for_next_inspection_tree_node.rb

@@ -0,0 +1,6 @@
+module SuperDiff
+  module Core
+    class PrefixForNextInspectionTreeNode < String
+    end
+  end
+end

data/lib/super_diff/core/prelude_for_next_inspection_tree_node.rb

@@ -0,0 +1,6 @@
+module SuperDiff
+  module Core
+    class PreludeForNextInspectionTreeNode < String
+    end
+  end
+end

data/lib/super_diff/core/recursion_guard.rb

@@ -0,0 +1,52 @@
+require "set"
+
+module SuperDiff
+  module Core
+    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|
+            !SuperDiff.primitive?(object) && already_seen?(object)
+          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?(object)
+        already_seen_object_ids.include?(object.object_id)
+      end
+
+      def self.already_seen_object_ids
+        Thread.current[RECURSION_GUARD_KEY] ||= Set.new
+      end
+    end
+  end
+end

data/lib/super_diff/core/tiered_lines.rb

@@ -0,0 +1,6 @@
+module SuperDiff
+  module Core
+    class TieredLines < Array
+    end
+  end
+end