Extract OperationalSequencers, DiffFormatters, and Differs

* Operational sequencers are things that perform a diff on two data
  structures and spit out a sort of internal representation of the diff
  as a sequence of operations.
* Diff formatters take those operations and then create a string
  representation of the diff for display purposes.
* Differs combine the two steps of generating an operational sequence
  and then formatting that as a diff.

Author: mcmire

lib/super_diff/diff_formatters/array.rb

@@ -0,0 +1,18 @@
+require_relative "../helpers"
+
+module SuperDiff
+  module DiffFormatters
+    class Array
+      def self.call(operations, indent:)
+        Collection.call(
+          open_token: "[",
+          close_token: "]",
+          operations: operations,
+          indent: indent
+        ) do |op|
+          Helpers.inspect_object(op.collection[op.index])
+        end
+      end
+    end
+  end
+end

lib/super_diff/diff_formatters/collection.rb

@@ -0,0 +1,84 @@
+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
+      end
+
+      def initialize(
+        open_token:,
+        close_token:,
+        operations:,
+        indent:,
+        &diff_line_for
+      )
+        @open_token = open_token
+        @close_token = close_token
+        @operations = operations
+        @indent = indent
+        @diff_line_for = diff_line_for
+      end
+
+      def call
+        ["  #{open_token}", *contents, "  #{close_token}"].join("\n")
+      end
+
+      private
+
+      attr_reader :open_token, :close_token, :operations, :indent,
+        :diff_line_for
+
+      def contents
+        operations.map do |op|
+          index = op.index
+          collection = op.collection
+
+          icon = ICONS.fetch(op.name, " ")
+          style_name = STYLES.fetch(op.name, :normal)
+          chunk = build_chunk(
+            diff_line_for.(op),
+            indent: indent,
+            icon: icon
+          )
+
+          if index < collection.length - 1
+            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")
+      end
+
+      def style_chunk(style_name, chunk)
+        chunk
+          .split("\n")
+          .map { |line| Helpers.style(style_name, line) }
+          .join("\n")
+      end
+    end
+  end
+end

lib/super_diff/diff_formatters/hash.rb

@@ -0,0 +1,26 @@
+require_relative "../helpers"
+require_relative "collection"
+
+module SuperDiff
+  module DiffFormatters
+    class Hash
+      def self.call(operations, indent:)
+        Collection.call(
+          open_token: "{",
+          close_token: "}",
+          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
+      end
+    end
+  end
+end

lib/super_diff/diff_formatters/multi_line_string.rb

@@ -0,0 +1,39 @@
+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
+      end
+
+      def call
+        lines.join("\n")
+      end
+
+      private
+
+      attr_reader :operations, :indent
+
+      def lines
+        operations.map do |op|
+          text = op.collection[op.index]
+
+          case op.name
+          when :noop
+            Helpers.style(:normal, "  #{text}")
+          when :insert
+            Helpers.style(:inserted, "+ #{text}")
+          when :delete
+            Helpers.style(:deleted, "- #{text}")
+          end
+        end
+      end
+    end
+  end
+end

lib/super_diff/differs/array.rb

@@ -0,0 +1,29 @@
+require_relative "../operational_sequencers/array"
+require_relative "../diff_formatters/array"
+
+module SuperDiff
+  module Differs
+    class Array
+      def self.call(expected, actual, indent:)
+        new(expected, actual, indent: indent).call
+      end
+
+      def initialize(expected, actual, indent:)
+        @expected = expected
+        @actual = actual
+        @indent = indent
+      end
+
+      def call
+        DiffFormatters::Array.call(
+          OperationalSequencers::Array.call(expected, actual),
+          indent: indent
+        )
+      end
+
+      private
+
+      attr_reader :expected, :actual, :indent
+    end
+  end
+end

lib/super_diff/differs/hash.rb

@@ -0,0 +1,29 @@
+require_relative "../operational_sequencers/hash"
+require_relative "../diff_formatters/hash"
+
+module SuperDiff
+  module Differs
+    class Hash
+      def self.call(expected, actual, indent:)
+        new(expected, actual, indent: indent).call
+      end
+
+      def initialize(expected, actual, indent:)
+        @expected = expected
+        @actual = actual
+        @indent = indent
+      end
+
+      def call
+        DiffFormatters::Hash.call(
+          OperationalSequencers::Hash.call(expected, actual),
+          indent: indent
+        )
+      end
+
+      private
+
+      attr_reader :expected, :actual, :indent
+    end
+  end
+end

lib/super_diff/equality_matchers/array.rb

@@ -1,25 +1,15 @@
-require "patience_diff"
-
-require_relative "collection"
+require_relative "../differs/array"
+require_relative "base"
 
 module SuperDiff
   module EqualityMatchers
-    class Array < Collection
-      def initialize(expected, actual)
-        super(expected, actual)
-        @sequence_matcher = PatienceDiff::SequenceMatcher.new
-      end
-
+    class Array < Base
       def fail
-        diff = build_diff("[", "]") do |event|
-          inspect(event[:collection][event[:index]])
-        end
-
         <<~OUTPUT.strip
           Differing arrays.
 
-          #{style :deleted,  "Expected: #{expected.inspect}"}
-          #{style :inserted, "  Actual: #{actual.inspect}"}
+          #{Helpers.style :deleted,  "Expected: #{expected.inspect}"}
+          #{Helpers.style :inserted, "  Actual: #{actual.inspect}"}
 
           Diff:
 
@@ -29,42 +19,8 @@ def fail
 
       protected
 
-      def events
-        opcodes.flat_map do |code, a_start, a_end, b_start, b_end|
-          if code == :delete
-            (a_start..a_end).map do |index|
-              {
-                state: :deleted,
-                index: index,
-                collection: expected
-              }
-            end
-          elsif code == :insert
-            (b_start..b_end).map do |index|
-              {
-                state: :inserted,
-                index: index,
-                collection: actual
-              }
-            end
-          else
-            (b_start..b_end).map do |index|
-              {
-                state: :equal,
-                index: index,
-                collection: actual
-              }
-            end
-          end
-        end
-      end
-
-      private
-
-      attr_reader :sequence_matcher
-
-      def opcodes
-        sequence_matcher.diff_opcodes(expected, actual)
+      def diff
+        Differs::Array.call(expected, actual, indent: 4)
       end
     end
   end

lib/super_diff/equality_matchers/base.rb

@@ -1,12 +1,6 @@
-require_relative "../csi"
-
 module SuperDiff
   module EqualityMatchers
     class Base
-      ICONS = { deleted: "-", inserted: "+" }
-      STYLES = { inserted: :inserted, deleted: :deleted, equal: :normal }
-      COLORS = { normal: :plain, inserted: :green, deleted: :red }
-
       def self.call(expected, actual)
         new(expected, actual).call
       end
@@ -31,45 +25,6 @@ def call
       def fail
         raise NotImplementedError
       end
-
-      def style(style_name, text)
-        Csi::ColorHelper.public_send(COLORS.fetch(style_name), text)
-      end
-
-      def plural_type_for(value)
-        case value
-        when Numeric then "numbers"
-        when String then "strings"
-        when Symbol then "symbols"
-        else "objects"
-        end
-      end
-
-      def inspect(value)
-        case value
-        when ::Hash
-          value.inspect.
-            gsub(/([^,]+)=>([^,]+)/, '\1 => \2').
-            gsub(/:(\w+) => /, '\1: ').
-            gsub(/\{([^{}]+)\}/, '{ \1 }')
-        when String
-          newline = "⏎"
-          value.gsub(/\r\n/, newline).gsub(/\n/, newline).inspect
-        else
-          inspected_value = value.inspect
-          match = inspected_value.match(/\A#<([^ ]+)(.*)>\Z/)
-
-          if match
-            [
-              "#<#{match.captures[0]} {",
-              *match.captures[1].split(" ").map { |line| "  " + line },
-              "}>"
-            ].join("\n")
-          else
-            inspected_value
-          end
-        end
-      end
     end
   end
 end