super_diff 0.6.2 → 0.9.0

data/lib/super_diff/object_inspection/nodes.rb

@@ -1,48 +1,49 @@
 module SuperDiff
   module ObjectInspection
     module Nodes
-      autoload :Base, "super_diff/object_inspection/nodes/base"
-      autoload :Break, "super_diff/object_inspection/nodes/break"
-      autoload :Inspection, "super_diff/object_inspection/nodes/inspection"
-      autoload :Nesting, "super_diff/object_inspection/nodes/nesting"
-      autoload :Text, "super_diff/object_inspection/nodes/text"
       autoload(
-        :WhenEmpty,
-        "super_diff/object_inspection/nodes/when_empty",
+        :AsLinesWhenRenderingToLines,
+        "super_diff/object_inspection/nodes/as_lines_when_rendering_to_lines",
       )
       autoload(
-        :WhenMultiline,
-        "super_diff/object_inspection/nodes/when_multiline",
+        :AsPrefixWhenRenderingToLines,
+        "super_diff/object_inspection/nodes/as_prefix_when_rendering_to_lines",
       )
       autoload(
-        :WhenNonEmpty,
-        "super_diff/object_inspection/nodes/when_non_empty",
+        :AsPreludeWhenRenderingToLines,
+        "super_diff/object_inspection/nodes/as_prelude_when_rendering_to_lines",
       )
       autoload(
-        :WhenSingleline,
-        "super_diff/object_inspection/nodes/when_singleline",
+        :AsSingleLine,
+        "super_diff/object_inspection/nodes/as_single_line",
+      )
+      autoload :Base, "super_diff/object_inspection/nodes/base"
+      autoload :Inspection, "super_diff/object_inspection/nodes/inspection"
+      autoload :Nesting, "super_diff/object_inspection/nodes/nesting"
+      autoload :OnlyWhen, "super_diff/object_inspection/nodes/only_when"
+      autoload :Text, "super_diff/object_inspection/nodes/text"
+      autoload(
+        :WhenRenderingToLines,
+        "super_diff/object_inspection/nodes/when_rendering_to_lines",
+      )
+      autoload(
+        :WhenRenderingToString,
+        "super_diff/object_inspection/nodes/when_rendering_to_string",
       )
-
-      def self.fetch(type)
-        registry.fetch(type) do
-          raise(
-            KeyError,
-            "#{type.inspect} is not included in ObjectInspection::Nodes.registry!",
-          )
-        end
-      end
 
       def self.registry
-        @_registry ||= {
-          break: Break,
-          inspection: Inspection,
-          nesting: Nesting,
-          text: Text,
-          when_empty: WhenEmpty,
-          when_multiline: WhenMultiline,
-          when_non_empty: WhenNonEmpty,
-          when_singleline: WhenSingleline,
-        }
+        @_registry ||= [
+          AsLinesWhenRenderingToLines,
+          AsPrefixWhenRenderingToLines,
+          AsPreludeWhenRenderingToLines,
+          AsSingleLine,
+          Inspection,
+          Nesting,
+          OnlyWhen,
+          Text,
+          WhenRenderingToLines,
+          WhenRenderingToString,
+        ]
       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/object_inspection.rb

@@ -1,7 +1,18 @@
 module SuperDiff
   module ObjectInspection
     autoload :InspectionTree, "super_diff/object_inspection/inspection_tree"
-    autoload :Inspectors, "super_diff/object_inspection/inspectors"
+    autoload(
+      :InspectionTreeBuilders,
+      "super_diff/object_inspection/inspection_tree_builders",
+    )
     autoload :Nodes, "super_diff/object_inspection/nodes"
+    autoload(
+      :PrefixForNextNode,
+      "super_diff/object_inspection/prefix_for_next_node",
+    )
+    autoload(
+      :PreludeForNextNode,
+      "super_diff/object_inspection/prelude_for_next_node",
+    )
   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/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

data/lib/super_diff/operation_tree_flatteners/custom_object.rb

@@ -0,0 +1,28 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class CustomObject < Collection
+      protected
+
+      def open_token
+        "#<%<class>s {" % { class: operation_tree.underlying_object.class }
+      end
+
+      def close_token
+        "}>"
+      end
+
+      def item_prefix_for(operation)
+        key =
+          # Note: We could have used the right_key here too, they're both the
+          # same keys
+          if operation.respond_to?(:left_key)
+            operation.left_key
+          else
+            operation.key
+          end
+
+        "#{key}: "
+      end
+    end
+  end
+end

data/lib/super_diff/operation_tree_flatteners/default_object.rb

@@ -0,0 +1,32 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class DefaultObject < Collection
+      protected
+
+      def open_token
+        "#<#{operation_tree.underlying_object.class.name}:" +
+          SuperDiff::Helpers.object_address_for(
+            operation_tree.underlying_object
+          ) +
+          " {"
+      end
+
+      def close_token
+        "}>"
+      end
+
+      def item_prefix_for(operation)
+        key =
+          # Note: We could have used the right_key here too, they're both the
+          # same keys
+          if operation.respond_to?(:left_key)
+            operation.left_key
+          else
+            operation.key
+          end
+
+        "@#{key}="
+      end
+    end
+  end
+end

data/lib/super_diff/operation_tree_flatteners/hash.rb

@@ -0,0 +1,41 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class Hash < Collection
+      protected
+
+      def open_token
+        "{"
+      end
+
+      def close_token
+        "}"
+      end
+
+      def item_prefix_for(operation)
+        key = key_for(operation)
+
+        if format_keys_as_kwargs?
+          "#{key}: "
+        else
+          "#{key.inspect} => "
+        end
+      end
+
+      private
+
+      def format_keys_as_kwargs?
+        operation_tree.all? { |operation| key_for(operation).is_a?(Symbol) }
+      end
+
+      def key_for(operation)
+        # Note: We could have used the right_key here too, they're both the
+        # same keys
+        if operation.respond_to?(:left_key)
+          operation.left_key
+        else
+          operation.key
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/operation_tree_flatteners/multiline_string.rb

@@ -0,0 +1,17 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class MultilineString < Base
+      def build_tiered_lines
+        operation_tree.map do |operation|
+          Line.new(
+            type: operation.name,
+            indentation_level: indentation_level,
+            # TODO: Test that quotes and things don't get escaped but escape
+            # characters do
+            value: operation.value.inspect[1..-2].gsub(/\\"/, '"').gsub(/\\'/, "'")
+          )
+        end
+      end
+    end
+  end
+end