super_diff 0.1.0

data/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

data/lib/super_diff/diff_formatters/collection.rb

@@ -0,0 +1,107 @@
+module SuperDiff
+  module DiffFormatters
+    class Collection
+      ICONS = { delete: "-", insert: "+" }.freeze
+      STYLES = { insert: :inserted, delete: :deleted, noop: :normal }.freeze
+
+      def self.call(*args, &block)
+        new(*args, &block).call
+      end
+
+      def initialize(
+        open_token:,
+        close_token:,
+        operations:,
+        indent_level:,
+        add_comma:,
+        collection_prefix:,
+        build_item_prefix:
+      )
+        @open_token = open_token
+        @close_token = close_token
+        @operations = operations
+        @indent_level = indent_level
+        @add_comma = add_comma
+        @collection_prefix = collection_prefix
+        @build_item_prefix = build_item_prefix
+      end
+
+      def call
+        lines.join("\n")
+      end
+
+      private
+
+      attr_reader :open_token, :close_token, :operations, :indent_level,
+        :add_comma, :collection_prefix, :build_item_prefix
+
+      def lines
+        [
+          "  #{indentation}#{collection_prefix}#{open_token}",
+          *contents,
+          "  #{indentation}#{close_token}#{comma}",
+        ]
+      end
+
+      def contents
+        operations.map do |operation|
+          if operation.name == :change
+            operation.child_operations.to_diff(
+              indent_level: indent_level + 1,
+              collection_prefix: build_item_prefix.call(operation),
+              add_comma: operation.should_add_comma_after_displaying?,
+            )
+          else
+            icon = ICONS.fetch(operation.name, " ")
+            style_name = STYLES.fetch(operation.name, :normal)
+            chunk = build_chunk(
+              Helpers.inspect_object(operation.value, single_line: false),
+              prefix: build_item_prefix.call(operation),
+              icon: icon,
+            )
+
+            if operation.should_add_comma_after_displaying?
+              chunk << ","
+            end
+
+            style_chunk(style_name, chunk)
+          end
+        end
+      end
+
+      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)
+        chunk.
+          split("\n").
+          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

data/lib/super_diff/diff_formatters/hash.rb

@@ -0,0 +1,34 @@
+module SuperDiff
+  module DiffFormatters
+    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: -> (operation) {
+            key =
+              if operation.respond_to?(:left_key)
+                operation.left_key
+              else
+                operation.key
+              end
+
+            if key.is_a?(Symbol)
+              "#{key}: "
+            else
+              "#{key.inspect} => "
+            end
+          },
+          operations: operations,
+          indent_level: indent_level,
+          add_comma: add_comma?,
+        )
+      end
+    end
+  end
+end

data/lib/super_diff/diff_formatters/multi_line_string.rb

@@ -0,0 +1,31 @@
+module SuperDiff
+  module DiffFormatters
+    class MultiLineString < Base
+      def self.applies_to?(operations)
+        operations.is_a?(OperationSequences::MultiLineString)
+      end
+
+      def call
+        lines.join("\n")
+      end
+
+      private
+
+      def lines
+        operations.reduce([]) do |array, operation|
+          case operation.name
+          when :change
+            array << Helpers.style(:deleted, "- #{operation.left_value}")
+            array << Helpers.style(:inserted, "+ #{operation.right_value}")
+          when :delete
+            array << Helpers.style(:deleted, "- #{operation.value}")
+          when :insert
+            array << Helpers.style(:inserted, "+ #{operation.value}")
+          else
+            array << Helpers.style(:normal, "  #{operation.value}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/diff_formatters/object.rb

@@ -0,0 +1,27 @@
+module SuperDiff
+  module DiffFormatters
+    class Object < Base
+      def self.applies_to?(operations)
+        operations.is_a?(OperationSequences::Object)
+      end
+
+      def call
+        Collection.call(
+          open_token: "#<#{value_class} {",
+          close_token: "}>",
+          collection_prefix: collection_prefix,
+          build_item_prefix: -> (operation) { "#{operation.key}: " },
+          operations: operations,
+          indent_level: indent_level,
+          add_comma: add_comma?,
+        )
+      end
+
+      protected
+
+      def value_class
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/super_diff/diff_formatters.rb

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

data/lib/super_diff/differ.rb

@@ -0,0 +1,48 @@
+module SuperDiff
+  class Differ
+    def self.call(*args)
+      new(*args).call
+    end
+
+    def initialize(
+      expected,
+      actual,
+      indent_level: 0,
+      index_in_collection: nil,
+      extra_classes: [],
+      extra_operational_sequencer_classes: [],
+      extra_diff_formatter_classes: []
+    )
+      @expected = expected
+      @actual = actual
+      @indent_level = indent_level
+      @index_in_collection = index_in_collection
+      @extra_classes = extra_classes
+      @extra_operational_sequencer_classes = extra_operational_sequencer_classes
+      @extra_diff_formatter_classes = extra_diff_formatter_classes
+    end
+
+    def call
+      resolved_class.call(
+        expected,
+        actual,
+        indent_level: indent_level,
+        index_in_collection: index_in_collection,
+        extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+        extra_diff_formatter_classes: extra_diff_formatter_classes,
+      )
+    end
+
+    private
+
+    attr_reader :expected, :actual, :indent_level, :index_in_collection,
+      :extra_classes, :extra_operational_sequencer_classes,
+      :extra_diff_formatter_classes
+
+    def resolved_class
+      (Differs::DEFAULTS + extra_classes).find do |klass|
+        klass.applies_to?(expected) && klass.applies_to?(actual)
+      end
+    end
+  end
+end

data/lib/super_diff/differs/array.rb

@@ -0,0 +1,24 @@
+module SuperDiff
+  module Differs
+    class Array < Base
+      def self.applies_to?(value)
+        value.is_a?(::Array)
+      end
+
+      def call
+        DiffFormatters::Array.call(operations, indent_level: indent_level)
+      end
+
+      private
+
+      def operations
+        OperationalSequencers::Array.call(
+          expected: expected,
+          actual: actual,
+          extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+          extra_diff_formatter_classes: extra_diff_formatter_classes,
+        )
+      end
+    end
+  end
+end

data/lib/super_diff/differs/base.rb

@@ -0,0 +1,42 @@
+module SuperDiff
+  module Differs
+    class Base
+      def self.applies_to?(_value)
+        raise NotImplementedError
+      end
+
+      def self.call(*args)
+        new(*args).call
+      end
+
+      def initialize(
+        expected,
+        actual,
+        indent_level:,
+        index_in_collection: nil,
+        extra_operational_sequencer_classes: [],
+        extra_diff_formatter_classes: []
+      )
+        @expected = expected
+        @actual = actual
+        @indent_level = indent_level
+        @index_in_collection = index_in_collection
+        @extra_operational_sequencer_classes = extra_operational_sequencer_classes
+        @extra_diff_formatter_classes = extra_diff_formatter_classes
+      end
+
+      def call
+        raise NotImplementedError
+      end
+
+      protected
+
+      attr_reader :expected, :actual, :indent_level, :index_in_collection,
+        :extra_operational_sequencer_classes, :extra_diff_formatter_classes
+
+      def indentation
+        " " * (indent_level * 2)
+      end
+    end
+  end
+end

data/lib/super_diff/differs/empty.rb

@@ -0,0 +1,13 @@
+module SuperDiff
+  module Differs
+    class Empty < Base
+      def self.applies_to?(_value)
+        true
+      end
+
+      def call
+        ""
+      end
+    end
+  end
+end

data/lib/super_diff/differs/hash.rb

@@ -0,0 +1,24 @@
+module SuperDiff
+  module Differs
+    class Hash < Base
+      def self.applies_to?(value)
+        value.is_a?(::Hash)
+      end
+
+      def call
+        DiffFormatters::Hash.call(operations, indent_level: indent_level)
+      end
+
+      private
+
+      def operations
+        OperationalSequencers::Hash.call(
+          expected: expected,
+          actual: actual,
+          extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+          extra_diff_formatter_classes: extra_diff_formatter_classes,
+        )
+      end
+    end
+  end
+end

data/lib/super_diff/differs/multi_line_string.rb

@@ -0,0 +1,27 @@
+module SuperDiff
+  module Differs
+    class MultiLineString < Base
+      def self.applies_to?(value)
+        value.is_a?(::String) && value.include?("\n")
+      end
+
+      def call
+        DiffFormatters::MultiLineString.call(
+          operations,
+          indent_level: indent_level,
+        )
+      end
+
+      private
+
+      def operations
+        OperationalSequencers::MultiLineString.call(
+          expected: expected,
+          actual: actual,
+          extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+          extra_diff_formatter_classes: extra_diff_formatter_classes,
+        )
+      end
+    end
+  end
+end

data/lib/super_diff/differs/object.rb

@@ -0,0 +1,68 @@
+module SuperDiff
+  module Differs
+    class Object < Base
+      def self.applies_to?(value)
+        value.is_a?(::Object)
+      end
+
+      def self.call(
+        expected,
+        actual,
+        indent_level:,
+        index_in_collection:,
+        **rest
+      )
+        super(
+          expected,
+          actual,
+          indent_level: indent_level,
+          index_in_collection: index_in_collection,
+          **rest
+        )
+      end
+
+      def self.inspection_lines_for(value)
+        inspected_value = value.inspect
+        match = inspected_value.match(/\A#<([^ ]+)(.*)>\Z/)
+
+        if match
+          [
+            "#<#{match.captures[0]} {",
+            *match.captures[1].split(" ").map { |line| "  " + line },
+            "}>",
+          ]
+        else
+          [inspected_value]
+        end
+      end
+
+      def call
+        lines.join("\n")
+      end
+
+      private
+
+      attr_reader :expected, :actual, :indent_level, :index_in_collection
+
+      def lines
+        [
+          styled_lines_for("-", :deleted, expected),
+          styled_lines_for("+", :inserted, actual),
+        ]
+      end
+
+      def styled_lines_for(icon, style_name, value)
+        unstyled_lines_for(icon, value).map do |line|
+          Helpers.style(style_name, line)
+        end
+      end
+
+      def unstyled_lines_for(icon, value)
+        lines = self.class.inspection_lines_for(value).
+          map { |inspection_line| "#{icon} #{indentation}#{inspection_line}" }
+
+        lines
+      end
+    end
+  end
+end

data/lib/super_diff/differs.rb

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

data/lib/super_diff/equality_matcher.rb

@@ -0,0 +1,45 @@
+module SuperDiff
+  class EqualityMatcher
+    def self.call(*args)
+      new(*args).call
+    end
+
+    def initialize(
+      expected:,
+      actual:,
+      extra_classes: [],
+      extra_operational_sequencer_classes: [],
+      extra_diff_formatter_classes: []
+    )
+      @expected = expected
+      @actual = actual
+      @extra_classes = extra_classes
+      @extra_operational_sequencer_classes = extra_operational_sequencer_classes
+      @extra_diff_formatter_classes = extra_diff_formatter_classes
+    end
+
+    def call
+      resolved_class.call(
+        expected: expected,
+        actual: actual,
+        extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+        extra_diff_formatter_classes: extra_diff_formatter_classes,
+      )
+    end
+
+    private
+
+    attr_reader :expected, :actual, :extra_classes,
+      :extra_operational_sequencer_classes, :extra_diff_formatter_classes
+
+    def resolved_class
+      matching_class || EqualityMatchers::Object
+    end
+
+    def matching_class
+      (EqualityMatchers::DEFAULTS + extra_classes).find do |klass|
+        klass.applies_to?(expected) && klass.applies_to?(actual)
+      end
+    end
+  end
+end

data/lib/super_diff/equality_matchers/array.rb

@@ -0,0 +1,44 @@
+module SuperDiff
+  module EqualityMatchers
+    class Array < Base
+      def self.applies_to?(value)
+        value.class == ::Array
+      end
+
+      def fail
+        <<~OUTPUT.strip
+          Differing arrays.
+
+          #{
+            Helpers.style(
+              :deleted,
+              "Expected: #{Helpers.inspect_object(expected)}",
+            )
+          }
+          #{
+            Helpers.style(
+              :inserted,
+              "  Actual: #{Helpers.inspect_object(actual)}",
+            )
+          }
+
+          Diff:
+
+          #{diff}
+        OUTPUT
+      end
+
+      protected
+
+      def diff
+        Differs::Array.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/base.rb

@@ -0,0 +1,42 @@
+module SuperDiff
+  module EqualityMatchers
+    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
+        if expected == actual
+          ""
+        else
+          fail
+        end
+      end
+
+      protected
+
+      attr_reader :expected, :actual, :extra_operational_sequencer_classes,
+        :extra_diff_formatter_classes
+
+      def fail
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/super_diff/equality_matchers/hash.rb

@@ -0,0 +1,44 @@
+module SuperDiff
+  module EqualityMatchers
+    class Hash < Base
+      def self.applies_to?(value)
+        value.class == ::Hash
+      end
+
+      def fail
+        <<~OUTPUT.strip
+          Differing hashes.
+
+          #{
+            Helpers.style(
+              :deleted,
+              "Expected: #{Helpers.inspect_object(expected)}",
+            )
+          }
+          #{
+            Helpers.style(
+              :inserted,
+              "  Actual: #{Helpers.inspect_object(actual)}",
+            )
+          }
+
+          Diff:
+
+          #{diff}
+        OUTPUT
+      end
+
+      protected
+
+      def diff
+        Differs::Hash.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