super_diff 0.1.0

data/lib/super_diff/operational_sequencers/multi_line_string.rb

@@ -0,0 +1,85 @@
+module SuperDiff
+  module OperationalSequencers
+    class MultiLineString < Base
+      def self.applies_to?(value)
+        value.is_a?(::String) && value.include?("\n")
+      end
+
+      def initialize(*args)
+        super(*args)
+
+        @original_expected = @expected
+        @original_actual = @actual
+        @expected = split_into_lines(@expected)
+        @actual = split_into_lines(@actual)
+        @sequence_matcher = PatienceDiff::SequenceMatcher.new
+      end
+
+      protected
+
+      def unary_operations
+        opcodes.flat_map do |code, a_start, a_end, b_start, b_end|
+          if code == :delete
+            add_delete_operations(a_start..a_end)
+          elsif code == :insert
+            add_insert_operations(b_start..b_end)
+          else
+            add_noop_operations(b_start..b_end)
+          end
+        end
+      end
+
+      def operation_sequence_class
+        OperationSequences::Array
+      end
+
+      private
+
+      attr_reader :sequence_matcher, :original_expected, :original_actual
+
+      def split_into_lines(str)
+        str.split(/(\n)/).map { |v| v.tr("\n", "⏎") }.each_slice(2).map(&:join)
+      end
+
+      def opcodes
+        sequence_matcher.diff_opcodes(expected, actual)
+      end
+
+      def add_delete_operations(indices)
+        indices.map do |index|
+          Operations::UnaryOperation.new(
+            name: :delete,
+            collection: expected,
+            key: index,
+            index: index,
+            value: expected[index],
+          )
+        end
+      end
+
+      def add_insert_operations(indices)
+        indices.map do |index|
+          Operations::UnaryOperation.new(
+            name: :insert,
+            collection: actual,
+            key: index,
+            index: index,
+            value: actual[index],
+          )
+        end
+      end
+
+      def add_noop_operations(indices)
+        indices.map do |index|
+          Operations::UnaryOperation.new(
+            name: :noop,
+            collection: actual,
+            key: index,
+            index: index,
+            value: actual[index],
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/operational_sequencers/object.rb

@@ -0,0 +1,96 @@
+module SuperDiff
+  module OperationalSequencers
+    class Object < Base
+      def initialize(*args)
+        super(*args)
+
+        @expected_attributes = attribute_names.reduce({}) do |hash, name|
+          hash.merge(name => expected.public_send(name))
+        end
+
+        @actual_attributes = attribute_names.reduce({}) do |hash, name|
+          hash.merge(name => actual.public_send(name))
+        end
+      end
+
+      protected
+
+      def unary_operations
+        attribute_names.reduce([]) do |operations, name|
+          possibly_add_noop_operation_to(operations, name)
+          possibly_add_delete_operation_to(operations, name)
+          possibly_add_insert_operation_to(operations, name)
+          operations
+        end
+      end
+
+      def operation_sequence_class
+        OperationSequences::Object
+      end
+
+      def attribute_names
+        raise NotImplementedError
+      end
+
+      private
+
+      attr_reader :expected_attributes, :actual_attributes
+
+      def possibly_add_noop_operation_to(operations, attribute_name)
+        if should_add_noop_operation?(attribute_name)
+          operations << Operations::UnaryOperation.new(
+            name: :noop,
+            collection: actual_attributes,
+            key: attribute_name,
+            index: attribute_names.index(attribute_name),
+            value: actual_attributes[attribute_name],
+          )
+        end
+      end
+
+      def should_add_noop_operation?(attribute_name)
+        expected_attributes.include?(attribute_name) &&
+          actual_attributes.include?(attribute_name) &&
+          expected_attributes[attribute_name] == actual_attributes[attribute_name]
+      end
+
+      def possibly_add_delete_operation_to(operations, attribute_name)
+        if should_add_delete_operation?(attribute_name)
+          operations << Operations::UnaryOperation.new(
+            name: :delete,
+            collection: expected_attributes,
+            key: attribute_name,
+            index: attribute_names.index(attribute_name),
+            value: expected_attributes[attribute_name],
+          )
+        end
+      end
+
+      def should_add_delete_operation?(attribute_name)
+        expected_attributes.include?(attribute_name) && (
+          !actual_attributes.include?(attribute_name) ||
+          expected_attributes[attribute_name] != actual_attributes[attribute_name]
+        )
+      end
+
+      def possibly_add_insert_operation_to(operations, attribute_name)
+        if should_add_insert_operation?(attribute_name)
+          operations << Operations::UnaryOperation.new(
+            name: :insert,
+            collection: actual_attributes,
+            key: attribute_name,
+            index: attribute_names.index(attribute_name),
+            value: actual_attributes[attribute_name],
+          )
+        end
+      end
+
+      def should_add_insert_operation?(attribute_name)
+        !expected_attributes.include?(attribute_name) || (
+          actual_attributes.include?(attribute_name) &&
+          expected_attributes[attribute_name] != actual_attributes[attribute_name]
+        )
+      end
+    end
+  end
+end

data/lib/super_diff/operational_sequencers.rb

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

data/lib/super_diff/operations/binary_operation.rb

@@ -0,0 +1,47 @@
+module SuperDiff
+  module Operations
+    class BinaryOperation
+      attr_reader(
+        :name,
+        :left_collection,
+        :right_collection,
+        :left_key,
+        :right_key,
+        :left_value,
+        :right_value,
+        :left_index,
+        :right_index,
+        :child_operations,
+      )
+
+      def initialize(
+        name:,
+        left_collection:,
+        right_collection:,
+        left_index:,
+        right_index:,
+        left_key:,
+        right_key:,
+        left_value:,
+        right_value:,
+        child_operations: []
+      )
+        @name = name
+        @left_collection = left_collection
+        @right_collection = right_collection
+        @left_index = left_index
+        @right_index = right_index
+        @left_key = left_key
+        @right_key = right_key
+        @left_value = left_value
+        @right_value = right_value
+        @child_operations = child_operations
+      end
+
+      def should_add_comma_after_displaying?
+        left_index < left_collection.size - 1 ||
+          right_index < right_collection.size - 1
+      end
+    end
+  end
+end

data/lib/super_diff/operations/unary_operation.rb

@@ -0,0 +1,25 @@
+module SuperDiff
+  module Operations
+    class UnaryOperation
+      attr_reader(
+        :name,
+        :collection,
+        :key,
+        :value,
+        :index,
+      )
+
+      def initialize(name:, collection:, key:, value:, index:)
+        @name = name
+        @collection = collection
+        @key = key
+        @value = value
+        @index = index
+      end
+
+      def should_add_comma_after_displaying?
+        index < collection.size - 1
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/differ.rb

@@ -0,0 +1,30 @@
+module SuperDiff
+  module RSpec
+    module Differ
+      def self.diff(actual, expected)
+        if (
+          expected != actual &&
+          expected.class == actual.class &&
+          !expected.is_a?(Symbol) &&
+          !expected.is_a?(Integer) &&
+          !(
+            expected.is_a?(String) &&
+            actual.is_a?(String) &&
+            !expected.include?("\n") &&
+            !actual.include?("\n")
+          )
+        )
+          diff = SuperDiff::Differ.call(
+            expected,
+            actual,
+            extra_operational_sequencer_classes: RSpec.extra_operational_sequencer_classes,
+            extra_diff_formatter_classes: RSpec.extra_diff_formatter_classes,
+          )
+          "\n\n" + diff
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/monkey_patches.rb

@@ -0,0 +1,122 @@
+RSpec::Expectations.instance_eval do
+  def differ
+    SuperDiff::RSpec::Differ
+  end
+end
+
+# rubocop:disable all
+RSpec::Core::Formatters::ConsoleCodes.instance_eval do
+  # UPDATE: Patch so it returns nothing if code_or_symbol is nil
+  def console_code_for(code_or_symbol)
+    if code_or_symbol
+      if (config_method = config_colors_to_methods[code_or_symbol])
+        console_code_for RSpec.configuration.__send__(config_method)
+      elsif RSpec::Core::Formatters::ConsoleCodes::VT100_CODE_VALUES.key?(code_or_symbol)
+        code_or_symbol
+      else
+        RSpec::Core::Formatters::ConsoleCodes::VT100_CODES.fetch(code_or_symbol) do
+          console_code_for(:white)
+        end
+      end
+    end
+  end
+
+  # UPDATE: Patch so it does not apply a color if code_or_symbol is nil
+  def wrap(text, code_or_symbol)
+    if RSpec.configuration.color_enabled? && code = console_code_for(code_or_symbol)
+      "\e[#{code}m#{text}\e[0m"
+    else
+      text
+    end
+  end
+end
+
+RSpec::Core::Formatters::ExceptionPresenter.class_eval do
+  # UPDATE: Copy from SyntaxHighlighter::CodeRayImplementation
+  RESET_CODE = "\e[0m"
+
+  def initialize(exception, example, options={})
+    @exception               = exception
+    @example                 = example
+    # UPDATE: Use no color by default
+    @message_color           = options[:message_color]
+    @description             = options.fetch(:description)            { example.full_description }
+    @detail_formatter        = options.fetch(:detail_formatter)       { Proc.new {} }
+    @extra_detail_formatter  = options.fetch(:extra_detail_formatter) { Proc.new {} }
+    @backtrace_formatter     = options.fetch(:backtrace_formatter)    { RSpec.configuration.backtrace_formatter }
+    @indentation             = options.fetch(:indentation, 2)
+    @skip_shared_group_trace = options.fetch(:skip_shared_group_trace, false)
+    @failure_lines           = options[:failure_lines]
+  end
+
+  def add_shared_group_lines(lines, colorizer)
+    return lines if @skip_shared_group_trace
+
+    example.metadata[:shared_group_inclusion_backtrace].each do |frame|
+      # Update: Use red instead of the default color
+      lines << colorizer.wrap(frame.description, :failure)
+    end
+
+    lines
+  end
+
+  # UPDATE: Style the first part in blue and the snippet of the line that failed
+  # in white
+  def failure_slash_error_lines
+    lines = read_failed_lines
+
+    failure_slash_error = RSpec::Core::Formatters::ConsoleCodes.wrap(
+      "Failure/Error: ",
+      :detail
+    )
+
+    if lines.count == 1
+      lines[0] =
+        failure_slash_error +
+        RSpec::Core::Formatters::ConsoleCodes.wrap(lines[0].strip, :white)
+    else
+      least_indentation =
+        RSpec::Core::Formatters::SnippetExtractor.least_indentation_from(lines)
+      lines = lines.map do |line|
+        RSpec::Core::Formatters::ConsoleCodes.wrap(
+          line.sub(/^#{least_indentation}/, '  '),
+          :white
+        )
+      end
+      lines.unshift(failure_slash_error)
+    end
+
+    lines
+  end
+end
+
+RSpec::Matchers::BuiltIn::Eq.class_eval do
+  def failure_message
+    "\n" +
+      colorizer.wrap("expected: #{expected_formatted}\n", :failure) +
+      colorizer.wrap("     got: #{actual_formatted}\n\n", :success) +
+      colorizer.wrap("(compared using ==)\n", :detail)
+  end
+
+  def failure_message_when_negated
+    "\n" +
+      colorizer.wrap("expected: value != #{expected_formatted}\n", :failure) +
+      colorizer.wrap("     got: #{actual_formatted}\n\n", :success) +
+      colorizer.wrap("(compared using ==)\n", :detail)
+  end
+
+  private
+
+  def colorizer
+    RSpec::Core::Formatters::ConsoleCodes
+  end
+end
+
+RSpec::Core::Formatters::SyntaxHighlighter.class_eval do
+  private
+
+  def implementation
+    RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
+  end
+end
+# rubocop:enable all

data/lib/super_diff/rspec.rb

@@ -0,0 +1,19 @@
+require_relative "../super_diff"
+require_relative "rspec/differ"
+require_relative "rspec/monkey_patches"
+
+module SuperDiff
+  module RSpec
+    class << self
+      attr_accessor :extra_operational_sequencer_classes
+      attr_accessor :extra_diff_formatter_classes
+
+      def configure
+        yield self
+      end
+    end
+
+    self.extra_operational_sequencer_classes = []
+    self.extra_diff_formatter_classes = []
+  end
+end

data/lib/super_diff/value_inspection.rb

@@ -0,0 +1,11 @@
+module SuperDiff
+  class ValueInspection
+    attr_reader :beginning, :middle, :end
+
+    def initialize(args)
+      @beginning = args.fetch(:beginning)
+      @middle = args.fetch(:middle)
+      @end = args.fetch(:end)
+    end
+  end
+end

data/lib/super_diff/version.rb

@@ -0,0 +1,3 @@
+module SuperDiff
+  VERSION = "0.1.0".freeze
+end

data/lib/super_diff.rb

@@ -0,0 +1,50 @@
+require "patience_diff"
+require "diff-lcs"
+
+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/operations/unary_operation"
+require_relative "super_diff/operations/binary_operation"
+
+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/multi_line_string"
+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/empty"
+require_relative "super_diff/differs/hash"
+require_relative "super_diff/differs/multi_line_string"
+require_relative "super_diff/differs/object"
+require_relative "super_diff/differs"
+require_relative "super_diff/differ"

data/spec/examples.txt

@@ -0,0 +1,46 @@
+example_id                                     | status | run_time        |
+---------------------------------------------- | ------ | --------------- |
+./spec/integration/rspec_spec.rb[1:1:1]        | passed | 0.27057 seconds |
+./spec/integration/rspec_spec.rb[1:2:1]        | passed | 0.28658 seconds |
+./spec/integration/rspec_spec.rb[1:3:1]        | passed | 0.26733 seconds |
+./spec/integration/rspec_spec.rb[1:4:1]        | passed | 0.26849 seconds |
+./spec/integration/rspec_spec.rb[1:5:1]        | passed | 0.38883 seconds |
+./spec/integration/rspec_spec.rb[1:6:1]        | passed | 0.26895 seconds |
+./spec/integration/rspec_spec.rb[1:7:1]        | passed | 0.27548 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:1:1]  | passed | 0.0002 seconds  |
+./spec/unit/equality_matcher_spec.rb[1:1:2:1]  | passed | 0.00016 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:3:1]  | passed | 0.00034 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:4:1]  | passed | 0.00015 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:5:1]  | passed | 0.0001 seconds  |
+./spec/unit/equality_matcher_spec.rb[1:1:6:1]  | passed | 0.00007 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:7:1]  | passed | 0.0002 seconds  |
+./spec/unit/equality_matcher_spec.rb[1:1:8:1]  | passed | 0.00014 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:9:1]  | passed | 0.00119 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:10:1] | passed | 0.00065 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:11:1] | passed | 0.00023 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:12:1] | passed | 0.00032 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:13:1] | passed | 0.00037 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:14:1] | passed | 0.00034 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:15:1] | passed | 0.0005 seconds  |
+./spec/unit/equality_matcher_spec.rb[1:1:16:1] | passed | 0.00031 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:17:1] | passed | 0.0004 seconds  |
+./spec/unit/equality_matcher_spec.rb[1:1:18:1] | passed | 0.00031 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:19:1] | passed | 0.00049 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:20:1] | passed | 0.00061 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:21:1] | passed | 0.00064 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:22:1] | passed | 0.0005 seconds  |
+./spec/unit/equality_matcher_spec.rb[1:1:23:1] | passed | 0.00232 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:24:1] | passed | 0.00007 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:25:1] | passed | 0.0005 seconds  |
+./spec/unit/equality_matcher_spec.rb[1:1:26:1] | passed | 0.00057 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:27:1] | passed | 0.00058 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:28:1] | passed | 0.00064 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:29:1] | passed | 0.00053 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:30:1] | passed | 0.0004 seconds  |
+./spec/unit/equality_matcher_spec.rb[1:1:31:1] | passed | 0.0005 seconds  |
+./spec/unit/equality_matcher_spec.rb[1:1:32:1] | passed | 0.00072 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:33:1] | passed | 0.00115 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:34:1] | passed | 0.00184 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:35:1] | passed | 0.00196 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:36:1] | passed | 0.00015 seconds |
+./spec/unit/equality_matcher_spec.rb[1:1:37:1] | passed | 0.00014 seconds |