super_diff 0.5.3 → 0.8.0

data/lib/super_diff/object_inspection/nodes/when_rendering_to_lines.rb

@@ -0,0 +1,27 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class WhenRenderingToLines < Base
+        def self.node_name
+          :when_rendering_to_lines
+        end
+
+        def self.method_name
+          :when_rendering_to_lines
+        end
+
+        def render_to_string(*)
+          ""
+        end
+
+        def render_to_lines(object, type:, indentation_level:)
+          render_to_lines_in_subtree(
+            object,
+            type: type,
+            indentation_level: indentation_level,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/when_rendering_to_string.rb

@@ -0,0 +1,27 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class WhenRenderingToString < Base
+        def self.node_name
+          :when_rendering_to_string
+        end
+
+        def self.method_name
+          :when_rendering_to_string
+        end
+
+        def render_to_string(object)
+          if block
+            render_to_string_in_subtree(object)
+          else
+            immediate_value.to_s
+          end
+        end
+
+        def render_to_lines(*, **)
+          []
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/prefix_for_next_node.rb

@@ -0,0 +1,6 @@
+module SuperDiff
+  module ObjectInspection
+    class PrefixForNextNode < String
+    end
+  end
+end

data/lib/super_diff/object_inspection/prelude_for_next_node.rb

@@ -0,0 +1,6 @@
+module SuperDiff
+  module ObjectInspection
+    class PreludeForNextNode < String
+    end
+  end
+end

data/lib/super_diff/operation_tree_builders/array.rb

@@ -17,7 +17,7 @@ module SuperDiff
           operation_tree: operation_tree,
           expected: expected,
           actual: actual,
-          sequence: method(:sequence),
+          compare: method(:compare),
         )
       end
 
@@ -28,7 +28,7 @@ module SuperDiff
       class LcsCallbacks
         extend AttrExtras.mixin
 
-        pattr_initialize [:operation_tree!, :expected!, :actual!, :sequence!]
+        pattr_initialize [:operation_tree!, :expected!, :actual!, :compare!]
         public :operation_tree
 
         def match(event)
@@ -44,10 +44,10 @@ module SuperDiff
         end
 
         def change(event)
-          child_operations = sequence.call(event.old_element, event.new_element)
+          children = compare.(event.old_element, event.new_element)
 
-          if child_operations
-            add_change_operation(event, child_operations)
+          if children
+            add_change_operation(event, children)
           else
             add_delete_operation(event)
             add_insert_operation(event)
@@ -63,7 +63,6 @@ module SuperDiff
             key: event.old_position,
             value: event.old_element,
             index: event.old_position,
-            index_in_collection: expected.index(event.old_element),
           )
         end
 
@@ -74,7 +73,6 @@ module SuperDiff
             key: event.new_position,
             value: event.new_element,
             index: event.new_position,
-            index_in_collection: actual.index(event.new_element),
           )
         end
 
@@ -85,11 +83,10 @@ module SuperDiff
             key: event.new_position,
             value: event.new_element,
             index: event.new_position,
-            index_in_collection: actual.index(event.new_element),
           )
         end
 
-        def add_change_operation(event, child_operations)
+        def add_change_operation(event, children)
           operation_tree << Operations::BinaryOperation.new(
             name: :change,
             left_collection: expected,
@@ -100,7 +97,7 @@ module SuperDiff
             right_value: event.new_element,
             left_index: event.old_position,
             right_index: event.new_position,
-            child_operations: child_operations,
+            children: children,
           )
         end
       end

data/lib/super_diff/operation_tree_builders/base.rb

@@ -39,7 +39,7 @@ module SuperDiff
           )
             unmatched_delete_operations.delete(delete_operation)
 
-            if (child_operations = possible_comparison_of(
+            if (children = possible_comparison_of(
               delete_operation,
               insert_operation,
             ))
@@ -52,9 +52,9 @@ module SuperDiff
                 right_key: insert_operation.key,
                 left_value: delete_operation.collection[operation.key],
                 right_value: insert_operation.collection[operation.key],
-                left_index: delete_operation.index_in_collection,
-                right_index: insert_operation.index_in_collection,
-                child_operations: child_operations,
+                left_index: delete_operation.index,
+                right_index: insert_operation.index,
+                children: children,
               )
             else
               operation_tree << insert_operation
@@ -73,7 +73,7 @@ module SuperDiff
 
       def possible_comparison_of(operation, next_operation)
         if should_compare?(operation, next_operation)
-          sequence(operation.value, next_operation.value)
+          compare(operation.value, next_operation.value)
         else
           nil
         end
@@ -86,7 +86,7 @@ module SuperDiff
           next_operation.key == operation.key
       end
 
-      def sequence(expected, actual)
+      def compare(expected, actual)
         OperationTreeBuilders::Main.call(
           expected: expected,
           actual: actual,

data/lib/super_diff/operation_tree_builders/custom_object.rb

@@ -7,9 +7,12 @@ module SuperDiff
           actual.respond_to?(:attributes_for_super_diff)
       end
 
+      protected
+
       def build_operation_tree
-        # XXX This assumes that `expected` and `actual` are the same
-        OperationTrees::CustomObject.new([], value_class: expected.class)
+        # NOTE: It doesn't matter whether we use expected or actual here,
+        # because all we care about is the name of the class
+        OperationTrees::CustomObject.new([], underlying_object: actual)
       end
 
       def attribute_names

data/lib/super_diff/operation_tree_builders/default_object.rb

@@ -25,7 +25,7 @@ module SuperDiff
       def build_operation_tree
         # XXX This assumes that `expected` and `actual` are the same
         # TODO: Does this need to be find_operation_tree_for?
-        OperationTrees::DefaultObject.new([], value_class: expected.class)
+        OperationTrees::DefaultObject.new([], underlying_object: actual)
       end
 
       def find_operation_tree_for(value)

data/lib/super_diff/operation_tree_builders/defaults.rb

@@ -1,5 +1,5 @@
 module SuperDiff
   module OperationTreeBuilders
-    DEFAULTS = [Array, Hash, CustomObject].freeze
+    DEFAULTS = [Array, Hash, TimeLike, CustomObject].freeze
   end
 end

data/lib/super_diff/operation_tree_builders/hash.rb

@@ -53,7 +53,7 @@ module SuperDiff
                 ev2, av2 = expected[ek], actual[ek]
 
                 if (
-                  (!actual.include?(ek) || ev != av2) &&
+                  (!actual.include?(ek) || ev2 != av2) &&
                   operations.none? { |operation|
                     [:delete, :noop].include?(operation.name) &&
                       operation.key == ek
@@ -65,7 +65,6 @@ module SuperDiff
                     key: ek,
                     value: ev2,
                     index: ei2,
-                    index_in_collection: ei2,
                   )
                 end
               end
@@ -77,7 +76,6 @@ module SuperDiff
               key: ak,
               value: av,
               index: ai,
-              index_in_collection: ai,
             )
           else
             # (If we're here, it probably means that the key in 'actual' isn't
@@ -133,7 +131,6 @@ module SuperDiff
                     key: ek,
                     value: ev,
                     index: ei2,
-                    index_in_collection: ei2,
                   )
                 end
 
@@ -148,7 +145,6 @@ module SuperDiff
                     key: ak,
                     value: av,
                     index: ai,
-                    index_in_collection: ai,
                   )
                 end
               end
@@ -169,7 +165,6 @@ module SuperDiff
                 key: ak,
                 value: expected[ak],
                 index: ei,
-                index_in_collection: ei,
               )
             end
 
@@ -184,7 +179,6 @@ module SuperDiff
                 key: ak,
                 value: av,
                 index: ai,
-                index_in_collection: ai,
               )
             end
           end
@@ -207,7 +201,6 @@ module SuperDiff
             key: ek,
             value: ev,
             index: ei,
-            index_in_collection: ei,
           )
         end
 

data/lib/super_diff/operation_tree_builders/multiline_string.rb

@@ -38,12 +38,8 @@ module SuperDiff
 
       attr_reader :sequence_matcher, :original_expected, :original_actual
 
-      def split_into_lines(str)
-        str.
-          split(/(\r?\n)/).
-          each_slice(2).
-          map(&:join).
-          map { |line| line.inspect[1..-2] }
+      def split_into_lines(string)
+        string.scan(/.+(?:\r|\n|\r\n|\Z)/)
       end
 
       def opcodes

data/lib/super_diff/operation_tree_builders/time_like.rb

@@ -15,9 +15,9 @@ module SuperDiff
           "hour",
           "min",
           "sec",
-          "nsec",
+          "subsec",
           "zone",
-          "gmt_offset",
+          "utc_offset",
         ]
 
         # If timezones are different, also show a normalized timestamp at the

data/lib/super_diff/operation_tree_flatteners.rb

@@ -0,0 +1,20 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    autoload :Array, "super_diff/operation_tree_flatteners/array"
+    autoload :Base, "super_diff/operation_tree_flatteners/base"
+    autoload :Collection, "super_diff/operation_tree_flatteners/collection"
+    autoload(
+      :CustomObject,
+      "super_diff/operation_tree_flatteners/custom_object",
+    )
+    autoload(
+      :DefaultObject,
+      "super_diff/operation_tree_flatteners/default_object",
+    )
+    autoload :Hash, "super_diff/operation_tree_flatteners/hash"
+    autoload(
+      :MultilineString,
+      "super_diff/operation_tree_flatteners/multiline_string",
+    )
+  end
+end

data/lib/super_diff/operation_tree_flatteners/array.rb

@@ -0,0 +1,15 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class Array < Collection
+      protected
+
+      def open_token
+        "["
+      end
+
+      def close_token
+        "]"
+      end
+    end
+  end
+end

data/lib/super_diff/operation_tree_flatteners/base.rb

@@ -0,0 +1,54 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class Base
+      include ImplementationChecks
+      extend AttrExtras.mixin
+
+      method_object :operation_tree, [indentation_level: 0]
+
+      def call
+        beginning_lines + middle_lines + ending_lines
+      end
+
+      protected
+
+      def build_tiered_lines
+        unimplemented_instance_method!
+      end
+
+      private
+
+      def beginning_lines
+        if tiered_lines.empty?
+          []
+        elsif indentation_level > 0
+          [tiered_lines[0]]
+        else
+          [tiered_lines[0].with_complete_bookend(:open)]
+        end
+      end
+
+      def middle_lines
+        if tiered_lines.empty?
+          []
+        else
+          tiered_lines[1..-2]
+        end
+      end
+
+      def ending_lines
+        if tiered_lines.empty?
+          []
+        elsif indentation_level > 0
+          [tiered_lines[-1]]
+        else
+          [tiered_lines[-1].with_complete_bookend(:close)]
+        end
+      end
+
+      def tiered_lines
+        @_tiered_lines ||= build_tiered_lines
+      end
+    end
+  end
+end

data/lib/super_diff/operation_tree_flatteners/collection.rb

@@ -0,0 +1,139 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class Collection < Base
+      protected
+
+      def build_tiered_lines
+        [
+          Line.new(
+            type: :noop,
+            indentation_level: indentation_level,
+            value: open_token,
+            collection_bookend: :open,
+          ),
+          *inner_lines,
+          Line.new(
+            type: :noop,
+            indentation_level: indentation_level,
+            value: close_token,
+            collection_bookend: :close,
+          ),
+        ]
+      end
+
+      def inner_lines
+        @_inner_lines ||= operation_tree.
+          flat_map do |operation|
+            lines =
+              if operation.name == :change
+                build_lines_for_change_operation(operation)
+              else
+                build_lines_for_non_change_operation(operation)
+              end
+
+            maybe_add_prefix_at_beginning_of_lines(
+              maybe_add_comma_at_end_of_lines(lines, operation),
+              operation,
+            )
+          end
+      end
+
+      def maybe_add_prefix_at_beginning_of_lines(lines, operation)
+        if add_prefix_at_beginning_of_lines?(operation)
+          add_prefix_at_beginning_of_lines(lines, operation)
+        else
+          lines
+        end
+      end
+
+      def add_prefix_at_beginning_of_lines?(operation)
+        !!item_prefix_for(operation)
+      end
+
+      def add_prefix_at_beginning_of_lines(lines, operation)
+        [lines[0].prefixed_with(item_prefix_for(operation))] +
+          lines[1..-1]
+      end
+
+      def maybe_add_comma_at_end_of_lines(lines, operation)
+        if last_item_in_collection?(operation)
+          lines
+        else
+          add_comma_at_end_of_lines(lines)
+        end
+      end
+
+      def last_item_in_collection?(operation)
+        if operation.name == :change
+          operation.left_index == operation.left_collection.size - 1 &&
+            operation.right_index == operation.right_collection.size - 1
+        else
+          operation.index == operation.collection.size - 1
+        end
+      end
+
+      def add_comma_at_end_of_lines(lines)
+        lines[0..-2] + [lines[-1].with_comma]
+      end
+
+      def build_lines_for_change_operation(operation)
+        SuperDiff::RecursionGuard.guarding_recursion_of(
+          operation.left_collection,
+          operation.right_collection,
+        ) do |already_seen|
+          if already_seen
+            raise InfiniteRecursionError
+          else
+            operation.children.flatten(
+              indentation_level: indentation_level + 1,
+            )
+          end
+        end
+      end
+
+      def build_lines_for_non_change_operation(operation)
+        indentation_level = @indentation_level + 1
+
+        if recursive_operation?(operation)
+          [
+            Line.new(
+              type: operation.name,
+              indentation_level: indentation_level,
+              value: SuperDiff::RecursionGuard::PLACEHOLDER,
+            ),
+          ]
+        else
+          build_lines_from_inspection_of(
+            operation.value,
+            type: operation.name,
+            indentation_level: indentation_level,
+          )
+        end
+      end
+
+      def recursive_operation?(operation)
+        operation.value.equal?(operation.collection) ||
+          SuperDiff::RecursionGuard.already_seen?(operation.value)
+      end
+
+      def item_prefix_for(_operation)
+        ""
+      end
+
+      def build_lines_from_inspection_of(value, type:, indentation_level:)
+        SuperDiff.inspect_object(
+          value,
+          as_lines: true,
+          type: type,
+          indentation_level: indentation_level,
+        )
+      end
+
+      class InfiniteRecursionError < StandardError
+        def initialize(_message = nil)
+          super("Unhandled recursive data structure encountered!")
+        end
+      end
+    end
+  end
+end