super_diff 0.1.0

data/lib/super_diff/equality_matchers/multi_line_string.rb

@@ -0,0 +1,44 @@
+module SuperDiff
+  module EqualityMatchers
+    class MultiLineString < Base
+      def self.applies_to?(value)
+        value.is_a?(::String) && value.include?("\n")
+      end
+
+      def fail
+        <<~OUTPUT.strip
+          Differing strings.
+
+          #{
+            Helpers.style(
+              :deleted,
+              "Expected: #{Helpers.inspect_object(expected)}",
+            )
+          }
+          #{
+            Helpers.style(
+              :inserted,
+              "  Actual: #{Helpers.inspect_object(actual)}",
+            )
+          }
+
+          Diff:
+
+          #{diff}
+        OUTPUT
+      end
+
+      private
+
+      def diff
+        Differs::MultiLineString.call(
+          expected,
+          actual,
+          indent_level: 0,
+          extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+          extra_diff_formatter_classes: extra_diff_formatter_classes,
+        )
+      end
+    end
+  end
+end

data/lib/super_diff/equality_matchers/object.rb

@@ -0,0 +1,18 @@
+module SuperDiff
+  module EqualityMatchers
+    class Object < Base
+      def self.applies_to?(value)
+        value.class == ::Object
+      end
+
+      def fail
+        <<~OUTPUT.strip
+          Differing #{Helpers.plural_type_for(actual)}.
+
+          #{Helpers.style :deleted,  "Expected: #{expected.inspect}"}
+          #{Helpers.style :inserted, "  Actual: #{actual.inspect}"}
+        OUTPUT
+      end
+    end
+  end
+end

data/lib/super_diff/equality_matchers/single_line_string.rb

@@ -0,0 +1,28 @@
+module SuperDiff
+  module EqualityMatchers
+    class SingleLineString < Base
+      def self.applies_to?(value)
+        value.class == ::String
+      end
+
+      def fail
+        <<~OUTPUT.strip
+          Differing strings.
+
+          #{
+            Helpers.style(
+              :deleted,
+              "Expected: #{Helpers.inspect_object(expected)}",
+            )
+          }
+          #{
+            Helpers.style(
+              :inserted,
+              "  Actual: #{Helpers.inspect_object(actual)}",
+            )
+          }
+        OUTPUT
+      end
+    end
+  end
+end

data/lib/super_diff/equality_matchers.rb

@@ -0,0 +1,5 @@
+module SuperDiff
+  module EqualityMatchers
+    DEFAULTS = [Array, Hash, MultiLineString, SingleLineString, Object].freeze
+  end
+end

data/lib/super_diff/errors.rb

@@ -0,0 +1,20 @@
+module SuperDiff
+  class NoOperationalSequencerAvailableError < 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 operational sequencer available to handle an "expected" value of
+type #{expected.class} and an "actual" value of type #{actual.class}.
+      MESSAGE
+    end
+  end
+end

data/lib/super_diff/helpers.rb

@@ -0,0 +1,96 @@
+module SuperDiff
+  module Helpers
+    COLORS = { normal: :plain, inserted: :green, deleted: :red }.freeze
+
+    def self.style(style_name, text)
+      Csi::ColorHelper.public_send(COLORS.fetch(style_name), text)
+    end
+
+    def self.plural_type_for(value)
+      case value
+      when Numeric then "numbers"
+      when String then "strings"
+      when Symbol then "symbols"
+      else "objects"
+      end
+    end
+
+    def self.inspect_object(value_to_inspect, single_line: true)
+      case value_to_inspect
+      when ::Hash
+        inspect_hash(value_to_inspect, single_line: single_line)
+      when String
+        inspect_string(value_to_inspect)
+      when ::Array
+        inspect_array(value_to_inspect)
+      else
+        inspect_unclassified_object(value_to_inspect, single_line: single_line)
+      end
+    end
+
+    def self.inspect_hash(hash, single_line: true)
+      contents = hash.map do |key, value|
+        if key.is_a?(Symbol)
+          "#{key}: #{inspect_object(value)}"
+        else
+          "#{inspect_object(key)} => #{inspect_object(value)}"
+        end
+      end
+
+      if single_line
+        ["{", contents.join(", "), "}"].join(" ")
+      else
+        ValueInspection.new(
+          beginning: "{",
+          middle: contents.map.with_index do |line, index|
+            if index < contents.size - 1
+              line + ","
+            else
+              line
+            end
+          end,
+          end: "}",
+        )
+      end
+    end
+    private_class_method :inspect_hash
+
+    def self.inspect_string(string)
+      newline = "⏎"
+      string.gsub(/\r\n/, newline).gsub(/\n/, newline).inspect
+    end
+    private_class_method :inspect_string
+
+    def self.inspect_array(array)
+      "[" + array.map { |element| inspect_object(element) }.join(", ") + "]"
+    end
+    private_class_method :inspect_array
+
+    def self.inspect_unclassified_object(object, single_line: true)
+      if object.respond_to?(:attributes_for_super_diff)
+        attributes = object.attributes_for_super_diff
+        inspected_attributes =
+          attributes.map.with_index do |(key, value), index|
+            "#{key}: #{value.inspect}".tap do |line|
+              if index < attributes.size - 1
+                line << ","
+              end
+            end
+          end
+
+        if single_line
+          "#<#{object.class} #{inspected_attributes.join(" ")}>"
+        else
+          ValueInspection.new(
+            beginning: "#<#{object.class} {",
+            middle: inspected_attributes,
+            end: "}>",
+          )
+        end
+      else
+        object.inspect
+      end
+    end
+    private_class_method :inspect_unclassified_object
+  end
+end

data/lib/super_diff/operation_sequences/array.rb

@@ -0,0 +1,14 @@
+module SuperDiff
+  module OperationSequences
+    class Array < Base
+      def to_diff(indent_level:, collection_prefix:, add_comma:)
+        DiffFormatters::Array.call(
+          self,
+          indent_level: indent_level,
+          collection_prefix: collection_prefix,
+          add_comma: add_comma,
+        )
+      end
+    end
+  end
+end

data/lib/super_diff/operation_sequences/base.rb

@@ -0,0 +1,11 @@
+module SuperDiff
+  module OperationSequences
+    class Base < SimpleDelegator
+      # rubocop:disable Lint/UnusedMethodArgument
+      def to_diff(indent_level:, add_comma:, collection_prefix: nil)
+        raise NotImplementedError
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+    end
+  end
+end

data/lib/super_diff/operation_sequences/hash.rb

@@ -0,0 +1,14 @@
+module SuperDiff
+  module OperationSequences
+    class Hash < Base
+      def to_diff(indent_level:, collection_prefix:, add_comma:)
+        DiffFormatters::Hash.call(
+          self,
+          indent_level: indent_level,
+          collection_prefix: collection_prefix,
+          add_comma: add_comma,
+        )
+      end
+    end
+  end
+end

data/lib/super_diff/operation_sequences/object.rb

@@ -0,0 +1,14 @@
+module SuperDiff
+  module OperationSequences
+    class Object < Base
+      def to_diff(indent_level:, collection_prefix:, add_comma:)
+        DiffFormatters::Object.call(
+          self,
+          indent_level: indent_level,
+          collection_prefix: collection_prefix,
+          add_comma: add_comma,
+        )
+      end
+    end
+  end
+end

data/lib/super_diff/operational_sequencer.rb

@@ -0,0 +1,43 @@
+module SuperDiff
+  class OperationalSequencer
+    def self.call(*args)
+      new(*args).call
+    end
+
+    def initialize(
+      expected:,
+      actual:,
+      extra_classes: [],
+      extra_diff_formatter_classes: []
+    )
+      @expected = expected
+      @actual = actual
+      @extra_classes = extra_classes
+      @extra_diff_formatter_classes = extra_diff_formatter_classes
+    end
+
+    def call
+      if resolved_class
+        resolved_class.call(
+          expected: expected,
+          actual: actual,
+          extra_operational_sequencer_classes: extra_classes,
+          extra_diff_formatter_classes: extra_diff_formatter_classes,
+        )
+      else
+        raise NoOperationalSequencerAvailableError.create(expected, actual)
+      end
+    end
+
+    private
+
+    attr_reader :expected, :actual, :extra_classes,
+      :extra_diff_formatter_classes
+
+    def resolved_class
+      (OperationalSequencers::DEFAULTS + extra_classes).find do |klass|
+        klass.applies_to?(expected) && klass.applies_to?(actual)
+      end
+    end
+  end
+end

data/lib/super_diff/operational_sequencers/array.rb

@@ -0,0 +1,127 @@
+module SuperDiff
+  module OperationalSequencers
+    class Array < Base
+      def self.applies_to?(value)
+        value.is_a?(::Array)
+      end
+
+      def initialize(*args)
+        super(*args)
+
+        @lcs_callbacks = LcsCallbacks.new(
+          expected: expected,
+          actual: actual,
+          extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+          extra_diff_formatter_classes: extra_diff_formatter_classes,
+        )
+      end
+
+      def call
+        Diff::LCS.traverse_balanced(expected, actual, lcs_callbacks)
+        lcs_callbacks.operations
+      end
+
+      private
+
+      attr_reader :lcs_callbacks
+
+      class LcsCallbacks
+        attr_reader :operations
+
+        def initialize(
+          expected:,
+          actual:,
+          extra_operational_sequencer_classes:,
+          extra_diff_formatter_classes:
+        )
+          @expected = expected
+          @actual = actual
+          @operations = OperationSequences::Array.new([])
+          @extra_operational_sequencer_classes =
+            extra_operational_sequencer_classes
+          @extra_diff_formatter_classes = extra_diff_formatter_classes
+        end
+
+        def match(event)
+          operations << ::SuperDiff::Operations::UnaryOperation.new(
+            name: :noop,
+            collection: actual,
+            key: event.new_position,
+            value: event.new_element,
+            index: event.new_position,
+          )
+        end
+
+        def discard_a(event)
+          operations << ::SuperDiff::Operations::UnaryOperation.new(
+            name: :delete,
+            collection: expected,
+            key: event.old_position,
+            value: event.old_element,
+            index: event.old_position,
+          )
+        end
+
+        def discard_b(event)
+          operations << ::SuperDiff::Operations::UnaryOperation.new(
+            name: :insert,
+            collection: actual,
+            key: event.new_position,
+            value: event.new_element,
+            index: event.new_position,
+          )
+        end
+
+        def change(event)
+          child_operations = sequence(event.old_element, event.new_element)
+
+          if child_operations
+            operations << ::SuperDiff::Operations::BinaryOperation.new(
+              name: :change,
+              left_collection: expected,
+              right_collection: actual,
+              left_key: event.old_position,
+              right_key: event.new_position,
+              left_value: event.old_element,
+              right_value: event.new_element,
+              left_index: event.old_position,
+              right_index: event.new_position,
+              child_operations: child_operations,
+            )
+          else
+            operations << Operations::UnaryOperation.new(
+              name: :delete,
+              collection: expected,
+              key: event.old_position,
+              value: event.old_element,
+              index: event.old_position,
+            )
+            operations << Operations::UnaryOperation.new(
+              name: :insert,
+              collection: actual,
+              key: event.new_position,
+              value: event.new_element,
+              index: event.new_position,
+            )
+          end
+        end
+
+        private
+
+        attr_reader :expected, :actual, :extra_operational_sequencer_classes,
+          :extra_diff_formatter_classes
+
+        def sequence(expected, actual)
+          OperationalSequencer.call(
+            expected: expected,
+            actual: actual,
+            extra_classes: extra_operational_sequencer_classes,
+            extra_diff_formatter_classes: extra_diff_formatter_classes,
+          )
+        rescue NoOperationalSequencerAvailableError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/operational_sequencers/base.rb

@@ -0,0 +1,97 @@
+module SuperDiff
+  module OperationalSequencers
+    class Base
+      def self.applies_to?(_value)
+        raise NotImplementedError
+      end
+
+      def self.call(*args)
+        new(*args).call
+      end
+
+      def initialize(
+        expected:,
+        actual:,
+        extra_operational_sequencer_classes: [],
+        extra_diff_formatter_classes: []
+      )
+        @expected = expected
+        @actual = actual
+        @extra_operational_sequencer_classes =
+          extra_operational_sequencer_classes
+        @extra_diff_formatter_classes = extra_diff_formatter_classes
+      end
+
+      def call
+        i = 0
+        operations = operation_sequence_class.new([])
+
+        while i < unary_operations.length
+          operation = unary_operations[i]
+          next_operation = unary_operations[i + 1]
+          child_operations = possible_comparison_of(operation, next_operation)
+
+          if child_operations
+            operations << Operations::BinaryOperation.new(
+              name: :change,
+              left_collection: operation.collection,
+              right_collection: next_operation.collection,
+              left_key: operation.key,
+              right_key: operation.key,
+              left_value: operation.collection[operation.key],
+              right_value: next_operation.collection[operation.key],
+              left_index: operation.index,
+              right_index: operation.index,
+              child_operations: child_operations,
+            )
+            i += 2
+          else
+            operations << operation
+            i += 1
+          end
+        end
+
+        operations
+      end
+
+      protected
+
+      def unary_operations
+        raise NotImplementedError
+      end
+
+      def operation_sequence_class
+        raise NotImplementedError
+      end
+
+      private
+
+      attr_reader :expected, :actual, :extra_operational_sequencer_classes,
+        :extra_diff_formatter_classes
+
+      def possible_comparison_of(operation, next_operation)
+        if should_compare?(operation, next_operation)
+          sequence(operation, next_operation)
+        end
+      end
+
+      def should_compare?(operation, next_operation)
+        next_operation &&
+          operation.name == :delete &&
+          next_operation.name == :insert &&
+          next_operation.index == operation.index
+      end
+
+      def sequence(operation, next_operation)
+        OperationalSequencer.call(
+          expected: operation.value,
+          actual: next_operation.value,
+          extra_classes: extra_operational_sequencer_classes,
+          extra_diff_formatter_classes: extra_diff_formatter_classes,
+        )
+      rescue NoOperationalSequencerAvailableError
+        nil
+      end
+    end
+  end
+end

data/lib/super_diff/operational_sequencers/hash.rb

@@ -0,0 +1,82 @@
+module SuperDiff
+  module OperationalSequencers
+    class Hash < Base
+      def self.applies_to?(value)
+        value.is_a?(::Hash)
+      end
+
+      protected
+
+      def unary_operations
+        all_keys.reduce([]) do |operations, key|
+          possibly_add_noop_to(operations, key)
+          possibly_add_delete_to(operations, key)
+          possibly_add_insert_to(operations, key)
+          operations
+        end
+      end
+
+      def operation_sequence_class
+        OperationSequences::Hash
+      end
+
+      private
+
+      def all_keys
+        (expected.keys | actual.keys)
+      end
+
+      def possibly_add_noop_to(operations, key)
+        if should_add_noop_operation?(key)
+          operations << Operations::UnaryOperation.new(
+            name: :noop,
+            collection: actual,
+            key: key,
+            index: all_keys.index(key),
+            value: actual[key],
+          )
+        end
+      end
+
+      def should_add_noop_operation?(key)
+        expected.include?(key) &&
+          actual.include?(key) &&
+          expected[key] == actual[key]
+      end
+
+      def possibly_add_delete_to(operations, key)
+        if should_add_delete_operation?(key)
+          operations << Operations::UnaryOperation.new(
+            name: :delete,
+            collection: expected,
+            key: key,
+            index: all_keys.index(key),
+            value: expected[key],
+          )
+        end
+      end
+
+      def should_add_delete_operation?(key)
+        expected.include?(key) &&
+          (!actual.include?(key) || expected[key] != actual[key])
+      end
+
+      def possibly_add_insert_to(operations, key)
+        if should_add_insert_operation?(key)
+          operations << Operations::UnaryOperation.new(
+            name: :insert,
+            collection: actual,
+            key: key,
+            index: all_keys.index(key),
+            value: actual[key],
+          )
+        end
+      end
+
+      def should_add_insert_operation?(key)
+        !expected.include?(key) ||
+          (actual.include?(key) && expected[key] != actual[key])
+      end
+    end
+  end
+end