Add support for diffing within objects

Take the following example:

    Expected: [1, 2, [:a, :b, :c], 4]
      Actual: [1, 2, [:a, :x, :c], 4]

We *could* display this diff like this:

      [
        1,
        2,
    -   [:a, :b, :c],
    +   [:a, :x, :c],
        4
      ]

However, it would be much more helpful to show a diff like this:

      [
        1,
        2,
        [
          :a,
    -     :b,
    +     :x,
          :c
        ],
        4
      ]

In order to do this, the first step is to treat groups of operations
which consist of a delete followed immediately by an insert as a
"change". (So in this case, the fact that we are deleting `[:a, :b,
:c]`) and adding `[:a, :x, :c]` is a change.) From there, we modify all
diff formatters so that they look for these change operations. If we
encounter one, we can then run a diff on the deleted (or "left") value
and the inserted (or "right") value. This will spit out a new set of
operations, which we can then run through whatever diff formatter is
appropriate for the two values. There's some trickery involved here,
particularly when it comes to hashes and objects, but that's the
10,000-foot view.

One thing to note is that in order to do that last step, we have to add
a diff formatter factory which looks at the values being diffed and
figures out which class to use. Out of necessity I've extended this
strategy to the other types of classes we have as well. Also a part of
this change was adding a new type of classes called "operation
sequences". This is a collection of operations that knows how to format
itself.

Author: mcmire

lib/super_diff.rb

@@ -1 +1,45 @@
+require "patience_diff"
+require "pry-byebug"
+
+require_relative "super_diff/csi"
+require_relative "super_diff/errors"
+require_relative "super_diff/helpers"
+require_relative "super_diff/value_inspection"
+
+require_relative "super_diff/equality_matchers/base"
+require_relative "super_diff/equality_matchers/array"
+require_relative "super_diff/equality_matchers/hash"
+require_relative "super_diff/equality_matchers/multi_line_string"
+require_relative "super_diff/equality_matchers/single_line_string"
+require_relative "super_diff/equality_matchers/object"
+require_relative "super_diff/equality_matchers"
 require_relative "super_diff/equality_matcher"
+
+require_relative "super_diff/operation_sequences/base"
+require_relative "super_diff/operation_sequences/array"
+require_relative "super_diff/operation_sequences/hash"
+require_relative "super_diff/operation_sequences/object"
+
+require_relative "super_diff/operational_sequencers/base"
+require_relative "super_diff/operational_sequencers/array"
+require_relative "super_diff/operational_sequencers/hash"
+require_relative "super_diff/operational_sequencers/object"
+require_relative "super_diff/operational_sequencers"
+require_relative "super_diff/operational_sequencer"
+
+require_relative "super_diff/diff_formatters/collection"
+require_relative "super_diff/diff_formatters/base"
+require_relative "super_diff/diff_formatters/array"
+require_relative "super_diff/diff_formatters/hash"
+require_relative "super_diff/diff_formatters/multi_line_string"
+require_relative "super_diff/diff_formatters/object"
+require_relative "super_diff/diff_formatters"
+require_relative "super_diff/diff_formatter"
+
+require_relative "super_diff/differs/base"
+require_relative "super_diff/differs/array"
+require_relative "super_diff/differs/hash"
+require_relative "super_diff/differs/string"
+require_relative "super_diff/differs/object"
+require_relative "super_diff/differs"
+require_relative "super_diff/differ"

lib/super_diff/diff_formatter.rb

@@ -0,0 +1,38 @@
+module SuperDiff
+  class DiffFormatter
+    def self.call(*args)
+      raise "We don't need this anymore"
+      new(*args).call
+    end
+
+    def initialize(
+      operations,
+      indent_level:,
+      add_comma: false,
+      extra_classes: []
+    )
+      @operations = operations
+      @indent_level = indent_level
+      @add_comma = add_comma
+      @extra_classes = extra_classes
+    end
+
+    def call
+      resolved_class.call(
+        operations,
+        indent_level: indent_level,
+        add_comma: add_comma
+      )
+    end
+
+    private
+
+    attr_reader :operations, :indent_level, :add_comma, :extra_classes
+
+    def resolved_class
+      (DiffFormatters::DEFAULTS + extra_classes).detect do |klass|
+        klass.applies_to?(operations)
+      end
+    end
+  end
+end

lib/super_diff/diff_formatters.rb

@@ -0,0 +1,5 @@
+module SuperDiff
+  module DiffFormatters
+    DEFAULTS = [Array, Hash, MultiLineString]
+  end
+end

lib/super_diff/diff_formatters/array.rb

@@ -1,17 +1,20 @@
-require_relative "../helpers"
-
 module SuperDiff
   module DiffFormatters
-    class Array
-      def self.call(operations, indent:)
+    class Array < Base
+      def self.applies_to?(operations)
+        operations.is_a?(OperationSequences::Array)
+      end
+
+      def call
         Collection.call(
           open_token: "[",
           close_token: "]",
+          collection_prefix: collection_prefix,
+          build_item_prefix: -> (op) { "" },
           operations: operations,
-          indent: indent
-        ) do |op|
-          Helpers.inspect_object(op.collection[op.index])
-        end
+          indent_level: indent_level,
+          add_comma: add_comma?
+        )
       end
     end
   end

lib/super_diff/diff_formatters/base.rb

@@ -0,0 +1,37 @@
+module SuperDiff
+  module DiffFormatters
+    class Base
+      def self.applies_to?(operations)
+        raise NotImplementedError
+      end
+
+      def self.call(*args)
+        new(*args).call
+      end
+
+      def initialize(
+        operations,
+        indent_level:,
+        collection_prefix: "",
+        add_comma: false
+      )
+        @operations = operations
+        @indent_level = indent_level
+        @collection_prefix = collection_prefix
+        @add_comma = add_comma
+      end
+
+      def call
+        raise NotImplementedError
+      end
+
+      private
+
+      attr_reader :operations, :indent_level, :collection_prefix
+
+      def add_comma?
+        @add_comma
+      end
+    end
+  end
+end

lib/super_diff/diff_formatters/collection.rb

@@ -1,76 +1,90 @@
-require_relative "../helpers"
-
 module SuperDiff
   module DiffFormatters
     class Collection
       ICONS = { delete: "-", insert: "+" }
       STYLES = { insert: :inserted, delete: :deleted, noop: :normal }
 
-      def self.call(
-        open_token:,
-        close_token:,
-        operations:,
-        indent:,
-        &diff_line_for
-      )
-        new(
-          open_token: open_token,
-          close_token: close_token,
-          operations: operations,
-          indent: indent,
-          &diff_line_for
-        ).call
+      def self.call(*args, &block)
+        new(*args, &block).call
       end
 
       def initialize(
         open_token:,
         close_token:,
         operations:,
-        indent:,
-        &diff_line_for
+        indent_level:,
+        add_comma:,
+        collection_prefix:,
+        build_item_prefix:
       )
         @open_token = open_token
         @close_token = close_token
         @operations = operations
-        @indent = indent
-        @diff_line_for = diff_line_for
+        @indent_level = indent_level
+        @add_comma = add_comma
+        @collection_prefix = collection_prefix
+        @build_item_prefix = build_item_prefix
       end
 
       def call
-        ["  #{open_token}", *contents, "  #{close_token}"].join("\n")
+        lines.join("\n")
       end
 
       private
 
-      attr_reader :open_token, :close_token, :operations, :indent,
-        :diff_line_for
+      attr_reader :open_token, :close_token, :operations, :indent_level,
+        :add_comma, :collection_prefix, :build_item_prefix#, :diff_line_for
+
+      def lines
+        [
+          "  #{indentation}#{collection_prefix}#{open_token}",
+          *contents,
+          "  #{indentation}#{close_token}#{comma}"
+        ]
+      end
 
       def contents
         operations.map do |op|
-          index = op.index
-          collection = op.collection
+          if op.name == :change
+            max_size = [op.left_collection.size, op.right_collection.size].max
+            add_comma = op.index < max_size - 1
+            op.child_operations.to_diff(
+              indent_level: indent_level + 1,
+              collection_prefix: build_item_prefix.call(op),
+              add_comma: add_comma
+            )
+          else
+            collection = op.collection
+            icon = ICONS.fetch(op.name, " ")
+            style_name = STYLES.fetch(op.name, :normal)
+            chunk = build_chunk(
+              Helpers.inspect_object(op.value, single_line: false),
+              prefix: build_item_prefix.call(op),
+              icon: icon
+            )
 
-          icon = ICONS.fetch(op.name, " ")
-          style_name = STYLES.fetch(op.name, :normal)
-          chunk = build_chunk(
-            diff_line_for.(op),
-            indent: indent,
-            icon: icon
-          )
+            if op.index < collection.size - 1
+              chunk << ","
+            end
 
-          if index < collection.length - 1
-            chunk << ","
+            style_chunk(style_name, chunk)
           end
-
-          style_chunk(style_name, chunk)
         end
       end
 
-      def build_chunk(text, indent:, icon:)
-        text
-          .split("\n")
-          .map { |line| icon + (" " * (indent - 1)) + line }
-          .join("\n")
+      def build_chunk(content, prefix:, icon:)
+        lines =
+          if content.is_a?(ValueInspection)
+            [
+              indentation(offset: 1) + prefix + content.beginning,
+              *content.middle.map { |line| indentation(offset: 2) + line },
+              indentation(offset: 1) + content.end
+            ]
+          else
+            [indentation(offset: 1) + prefix + content]
+          end
+
+        lines.map { |line| icon + " " + line }.join("\n")
       end
 
       def style_chunk(style_name, chunk)
@@ -79,6 +93,18 @@ def style_chunk(style_name, chunk)
           .map { |line| Helpers.style(style_name, line) }
           .join("\n")
       end
+
+      def indentation(offset: 0)
+        " " * ((indent_level + offset) * 2)
+      end
+
+      def comma
+        if add_comma
+          ","
+        else
+          ""
+        end
+      end
     end
   end
 end

lib/super_diff/diff_formatters/hash.rb

@@ -1,25 +1,26 @@
-require_relative "../helpers"
-require_relative "collection"
-
 module SuperDiff
   module DiffFormatters
-    class Hash
-      def self.call(operations, indent:)
+    class Hash < Base
+      def self.applies_to?(operations)
+        operations.is_a?(OperationSequences::Hash)
+      end
+
+      def call
         Collection.call(
           open_token: "{",
           close_token: "}",
+          collection_prefix: collection_prefix,
+          build_item_prefix: -> (op) {
+            if op.key.is_a?(Symbol)
+              "#{op.key}: "
+            else
+              "#{op.key.inspect} => "
+            end
+          },
           operations: operations,
-          indent: indent
-        ) do |op|
-          key = op.key
-          inspected_value = Helpers.inspect_object(op.collection[op.key])
-
-          if key.is_a?(Symbol)
-            "#{key}: #{inspected_value}"
-          else
-            "#{key.inspect} => #{inspected_value}"
-          end
-        end
+          indent_level: indent_level,
+          add_comma: add_comma?
+        )
       end
     end
   end

lib/super_diff/diff_formatters/multi_line_string.rb

@@ -1,15 +1,8 @@
-require_relative "../helpers"
-
 module SuperDiff
   module DiffFormatters
-    class MultiLineString
-      def self.call(operations, indent:)
-        new(operations, indent: indent).call
-      end
-
-      def initialize(operations, indent:)
-        @operations = operations
-        @indent = indent
+    class MultiLineString < Base
+      def self.applies_to?(operations)
+        operations.is_a?(OperationSequences::MultiLineString)
       end
 
       def call
@@ -18,19 +11,18 @@ def call
 
       private
 
-      attr_reader :operations, :indent
-
       def lines
-        operations.map do |op|
-          text = op.collection[op.index]
-
+        operations.inject([]) do |array, op|
           case op.name
-          when :noop
-            Helpers.style(:normal, "  #{text}")
-          when :insert
-            Helpers.style(:inserted, "+ #{text}")
+          when :change
+            array << Helpers.style(:deleted, "- #{op.left_value}")
+            array << Helpers.style(:inserted, "+ #{op.right_value}")
           when :delete
-            Helpers.style(:deleted, "- #{text}")
+            array << Helpers.style(:deleted, "- #{op.value}")
+          when :insert
+            array << Helpers.style(:inserted, "+ #{op.value}")
+          else
+            array << Helpers.style(:normal, "  #{op.value}")
           end
         end
       end