specdiff 0.2.0 → 0.3.0.pre.rc1

data/examples/rspec/spec/spec_helper.rb

@@ -0,0 +1,68 @@
+Bundler.require
+require "specdiff/rspec"
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # enable test focusing
+  config.filter_run_when_matching :focus
+
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  # https://rspec.info/features/3-12/rspec-core/configuration/zero-monkey-patching-mode/
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+end
+
+class MyBasicObjectClass < BasicObject
+end
+
+class ConstantForTheSolePurposeOfUndefiningInspect
+  undef_method :inspect
+end

data/examples/webmock/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../..
   specs:
-    specdiff (0.2.0)
+    specdiff (0.3.0.pre.rc1)
       diff-lcs (~> 1.5)
       hashdiff (~> 1.0)
 
@@ -12,7 +12,7 @@ GEM
       public_suffix (>= 2.0.2, < 6.0)
     crack (0.4.5)
       rexml
-    diff-lcs (1.5.0)
+    diff-lcs (1.5.1)
     domain_name (0.6.20231109)
     ffi (1.16.3)
     ffi-compiler (1.0.1)

data/lib/specdiff/colorize.rb

@@ -25,7 +25,12 @@ module Specdiff::Colorize
     "\e[33m#{text}\e[0m"
   end
 
+  # this color may have bad contrast
   def blue(text)
     "\e[34m#{text}\e[0m"
   end
+
+  def cyan(text)
+    "\e[36m#{text}\e[0m"
+  end
 end

data/lib/specdiff/diff.rb

@@ -21,8 +21,10 @@
   def inspect
     if empty?
       "<Specdiff::Diff (empty)>"
-    else
+    elsif raw.respond_to?(:bytesize)
       "<Specdiff::Diff w/ #{raw&.bytesize || 0} bytes of #raw diff>"
+    else
+      "<Specdiff::Diff #{raw.inspect}>"
     end
   end
 end

data/lib/specdiff/differ/hashdiff.rb

@@ -3,17 +3,67 @@ require "hashdiff"
 class Specdiff::Differ::Hashdiff
   extend ::Specdiff::Colorize
 
+  VALUE_CHANGE_PERCENTAGE_THRESHOLD = 0.2
+  TOTAL_CHANGES_FOR_GROUPING_THRESHOLD = 9
+
+  NEWLINE = "\n"
+
   def self.diff(a, b)
     # array_path: true returns the path as an array, which differentiates
     # between symbol keys and string keys in hashes, while the string
     # representation does not.
     # hmm it really seems like use_lcs: true gives much less human-readable
     # (human-comprehensible) output when arrays are involved.
-    ::Hashdiff.diff(
+    hashdiff_diff = ::Hashdiff.diff(
       a.value, b.value,
       array_path: true,
       use_lcs: false,
     )
+
+    return hashdiff_diff if hashdiff_diff.empty?
+
+    change_percentage = _calculate_change_percentage(hashdiff_diff)
+
+    if change_percentage >= VALUE_CHANGE_PERCENTAGE_THRESHOLD
+      hashdiff_diff
+    else
+      a_text = ::Specdiff.hashprint(a.value)
+      b_text = ::Specdiff.hashprint(b.value)
+
+      diff = ::Specdiff.diff(a_text, b_text)
+
+      if diff.empty?
+        []
+      else
+        diff.a.type = a.type
+        diff.b.type = b.type
+
+        diff
+      end
+    end
+  end
+
+  def self._calculate_change_percentage(hashdiff_diff)
+    value_change_count = hashdiff_diff.count { |element| element[0] == "~" }
+    addition_count = hashdiff_diff.count { |element| element[0] == "+" }
+    deletion_count = hashdiff_diff.count { |element| element[0] == "-" }
+    # puts "hashdiff_diff: #{hashdiff_diff.inspect}"
+    # puts "value_change_count: #{value_change_count.inspect}"
+    # puts "addition_count: #{addition_count.inspect}"
+    # puts "deletion_count: #{deletion_count.inspect}"
+
+    total_number_of_changes = [
+      value_change_count,
+      addition_count,
+      deletion_count,
+    ].sum
+
+    change_fraction = Rational(value_change_count, total_number_of_changes)
+    change_percentage = change_fraction.to_f
+    # puts "change_fraction: #{change_fraction.inspect}"
+    # puts "change_percentage: #{change_percentage.inspect}"
+
+    change_percentage
   end
 
   def self.empty?(diff)
@@ -23,37 +73,66 @@ class Specdiff::Differ::Hashdiff
   def self.stringify(diff)
     result = +""
 
-    diff.raw.each do |change|
-      type = change[0] # the char '+', '-' or '~'
-      path = change[1] # for example key1.key2[2] (as ["key1", :key2, 2])
-      path2 = _stringify_path(path)
+    total_changes = diff.raw.size
+    group_with_newlines = total_changes >= TOTAL_CHANGES_FOR_GROUPING_THRESHOLD
+
+    # hashdiff returns a structure like so:
+    # change[0] = '+', '-' or '~'. denoting type (addition, deletion or change)
+    # change[1] = the path to the change, in array form
+    # change[2] = the value, or the from value in case of '~'
+    # change[3] = the to value, only present when '~'
+    changes_grouped_by_type = diff.raw.group_by { |change| change[0] }
+    if (changes_grouped_by_type.keys - ["+", "-", "~"]).size > 0
+      $stderr.puts(
+        "Specdiff: hashdiff returned unexpected types: #{diff.raw.inspect}"
+      )
+    end
 
-      if type == "+"
-        value = change[2]
+    deletions = changes_grouped_by_type["-"] || []
+    additions = changes_grouped_by_type["+"] || []
+    value_changes = changes_grouped_by_type["~"] || []
 
-        result << "added #{path2} with value #{value.inspect}"
-      elsif type == "-"
-        value = change[2]
+    deletions.each do |change|
+      value = change[2]
+      path = _stringify_path(change[1])
 
-        result << "removed #{path2} with value #{value.inspect}"
-      elsif type == "~"
-        from = change[2]
-        to = change[3]
+      result << "missing key: #{path} (#{::Specdiff.diff_inspect(value)})"
+      result << NEWLINE
+    end
 
-        result << "changed #{path2} from #{from.inspect} to #{to.inspect}"
-      else
-        result << change.inspect
-      end
+    if deletions.any? && additions.any? && group_with_newlines
+      result << NEWLINE
+    end
+
+    additions.each do |change|
+      value = change[2]
+      path = _stringify_path(change[1])
+
+      result << "    new key: #{path} (#{::Specdiff.diff_inspect(value)})"
+      result << NEWLINE
+    end
+
+    if additions.any? && value_changes.any? && group_with_newlines
+      result << NEWLINE
+    end
+
+    value_changes.each do |change|
+      from = change[2]
+      to = change[3]
+      path = _stringify_path(change[1])
 
-      result << "\n"
+      from_inspected = ::Specdiff.diff_inspect(from)
+      to_inspected = ::Specdiff.diff_inspect(to)
+      result << "changed key: #{path} (#{from_inspected} -> #{to_inspected})"
+      result << NEWLINE
     end
 
     colorize_by_line(result) do |line|
-      if line.start_with?("removed")
+      if line.start_with?("missing key:")
         red(line)
-      elsif line.start_with?("added")
+      elsif line.start_with?(/\s+new key:/)
         green(line)
-      elsif line.start_with?("changed")
+      elsif line.start_with?("changed key:")
         yellow(line)
       else
         reset_color(line)

data/lib/specdiff/differ/not_found.rb

@@ -2,7 +2,7 @@
 class Specdiff::Differ::NotFound
   def self.diff(a, b)
     comparison = "!="
-    comparison = "=" if a.value == b.value
+    comparison = "==" if a.value == b.value
 
     a_representation = _representation_for(a)
     b_representation = _representation_for(b)

data/lib/specdiff/differ/text.rb

@@ -15,20 +15,32 @@ class Specdiff::Differ::Text
     b_value = b.value
 
     if a_value.encoding != b_value.encoding
-      return <<~MSG
+      return colorize_by_line(<<~MSG) do |line|
         Strings have different encodings:
           #{a.value.encoding.inspect} != #{b.value.encoding.inspect}
       MSG
+        # makes it stand out a bit more from the red of rspec output
+        reset_color(line)
+      end
     end
 
     diff = ""
 
+    # if there are no newlines then the text differ doesn't produce any valuable
+    # output. "word diffing" would improve this case.
+    if a_value.count(NEWLINE) <= 1 && b_value.count(NEWLINE) <= 1
+      return diff
+    end
+
     a_lines = a_value.split(NEWLINE).map! { _1.chomp }
     b_lines = b_value.split(NEWLINE).map! { _1.chomp }
+
+    file_length_difference = 0
+
     hunks = ::Diff::LCS.diff(a_lines, b_lines).map do |piece|
       ::Diff::LCS::Hunk.new(
-        a_lines, b_lines, piece, CONTEXT_LINES, 0,
-      )
+        a_lines, b_lines, piece, CONTEXT_LINES, file_length_difference,
+      ).tap { |hunk| file_length_difference = hunk.file_length_difference }
     end
 
     hunks.each_cons(2) do |prev_hunk, current_hunk|
@@ -36,7 +48,7 @@ class Specdiff::Differ::Text
         if current_hunk.overlaps?(prev_hunk)
           current_hunk.merge(prev_hunk)
         else
-          diff << prev_hunk.diff(:unified).to_s
+          diff << prev_hunk.diff(:unified)
         end
       ensure
         diff << NEWLINE
@@ -44,12 +56,14 @@ class Specdiff::Differ::Text
     end
 
     if hunks.last
-      diff << hunks.last.diff(:unified).to_s
+      diff << NEWLINE
+      diff << hunks.last.diff(:unified)
     end
 
     return diff if diff == ""
 
-    diff << "\n"
+    diff << NEWLINE
+    diff.lstrip!
 
     return colorize_by_line(diff) do |line|
       case line[0].chr
@@ -59,7 +73,7 @@ class Specdiff::Differ::Text
         red(line)
       when "@"
         if line[1].chr == "@"
-          blue(line)
+          cyan(line)
         else
           reset_color(line)
         end

data/lib/specdiff/hashprint.rb

@@ -0,0 +1,154 @@
+# Tries to print nested hash/array structures such that they are as convenient
+# as possible for a diffing algorithm designed for text (like source code).
+# Basically tries to reproduce consistent literal source code form for ruby
+# hashes and arrays and objects (although it falls back to #inspect).
+class Specdiff::Hashprint
+  def self.call(...)
+    new.call(...)
+  end
+
+  INDENTATION_SPACES = 2
+  SPACE = " ".freeze
+  COMMA = ",".freeze
+  NEWLINE = "\n".freeze
+
+  def call(thing)
+    @indentation_level = 0
+    @indentation_per_level = SPACE * INDENTATION_SPACES
+    @indent = ""
+    @skip_next_opening_indent = false
+
+    @output = StringIO.new
+
+    output(thing)
+
+    @output.string
+  end
+
+private
+
+  def recalculate_indent
+    @indent = @indentation_per_level * @indentation_level
+  end
+
+  def increase_indentation
+    @indentation_level += 1
+    recalculate_indent
+  end
+
+  def decrease_indentation
+    @indentation_level -= 1
+    recalculate_indent
+  end
+
+  def with_indentation_level(temporary_level)
+    old_level = @indentation_level
+    @indentation_level = temporary_level
+    recalculate_indent
+
+    yield
+
+    @indentation_level = old_level
+    recalculate_indent
+  end
+
+  def skip_next_opening_indent
+    @skip_next_opening_indent = true
+
+    nil
+  end
+
+  def this_indent_should_be_skipped
+    if @skip_next_opening_indent
+      @skip_next_opening_indent = false
+      true
+    else
+      false
+    end
+  end
+
+  # #=== allows us to rely on Module implementing #=== instead of relying on the
+  # thing (which could be any kind of wacky object) having to implement
+  # #is_a? or #kind_of?
+  def output(thing)
+    if Hash === thing
+      output_hash(thing)
+    elsif Array === thing
+      output_array(thing)
+    else
+      output_unknown(thing)
+    end
+  end
+
+  HASH_OPEN = "{".freeze
+  HASH_CLOSE = "}".freeze
+  HASHROCKET = "=>".freeze
+  COLON = ":".freeze
+
+  def output_hash(hash)
+    @output << @indent unless this_indent_should_be_skipped
+
+    @output << HASH_OPEN
+    # unless hash.empty?
+      @output << NEWLINE
+
+      increase_indentation
+      hash.each do |key, value|
+        @output << @indent
+
+        if key.is_a?(Symbol)
+          @output << key
+          @output << COLON
+          @output << SPACE
+        else
+          @output << ::Specdiff.diff_inspect(key)
+          @output << SPACE
+          @output << HASHROCKET
+          @output << SPACE
+        end
+
+        skip_next_opening_indent
+        output(value)
+
+        @output << COMMA
+        @output << NEWLINE
+      end
+      decrease_indentation
+
+      @output << @indent
+    # end
+
+    @output << HASH_CLOSE
+  end
+
+  ARRAY_OPEN = "[".freeze
+  ARRAY_CLOSE = "]".freeze
+
+  def output_array(array)
+    @output << @indent unless this_indent_should_be_skipped
+
+    @output << ARRAY_OPEN
+
+    # unless array.empty?
+      @output << NEWLINE
+
+      increase_indentation
+      array.each do |element|
+        output(element)
+        @output << COMMA
+        @output << NEWLINE
+      end
+      decrease_indentation
+
+      @output << @indent
+    # end
+
+    @output << ARRAY_CLOSE
+  end
+
+  def output_unknown(thing)
+    @output << @indent unless this_indent_should_be_skipped
+
+    @output << ::Specdiff.diff_inspect(thing)
+  end
+end

data/lib/specdiff/inspect.rb

@@ -0,0 +1,41 @@
+class Specdiff::Inspect
+  TIME_FORMAT = "%Y-%m-%d %H:%M:%S %z"
+  DATE_FORMAT = "%Y-%m-%d"
+
+  def self.call(...)
+    new.call(...)
+  end
+
+  # #=== allows us to rely on Module implementing #=== instead of relying on the
+  # thing (which could be any kind of wacky object) having to implement
+  # #is_a? or #kind_of?
+  def call(thing)
+    if Time === thing
+      "#<Time: #{thing.strftime(TIME_FORMAT)}>"
+    elsif DateTime === thing
+      "#<DateTime: #{thing.rfc3339}>"
+    elsif Date === thing
+      "#<Date: #{thing.strftime(DATE_FORMAT)}>"
+    elsif defined?(BigDecimal) && BigDecimal === thing
+      "#<BigDecimal: #{thing.to_s('F')}>"
+    else
+      begin
+        thing.inspect
+      rescue NoMethodError
+        inspect_anyway(thing)
+      end
+    end
+  end
+
+  private def inspect_anyway(uninspectable)
+    "#<uninspectable #{class_of(uninspectable)}>"
+  end
+
+  private def class_of(uninspectable)
+    uninspectable.class
+  rescue NoMethodError
+    singleton_class = class << uninspectable; self; end
+    singleton_class.ancestors
+      .find { |ancestor| !ancestor.equal?(singleton_class) }
+  end
+end

data/lib/specdiff/rspec.rb

@@ -0,0 +1,33 @@
+class RSpec::Support::Differ
+  alias old_diff diff
+
+  def diff(actual, expected)
+    diff = ::Specdiff.diff(expected, actual)
+    if diff.empty?
+      ""
+    else
+      "\n#{diff}"
+    end
+  end
+end
+
+# This stops rspec from truncating strings w/ ellipsis, as well as making the
+# "inspect" output consistent with specdiff's.
+class RSpec::Support::ObjectFormatter
+  class SpecdiffCustomInspector < BaseInspector
+    def self.can_inspect?(_)
+      true
+    end
+
+    def inspect
+      ::Specdiff.diff_inspect(object)
+    end
+  end
+
+  remove_const("INSPECTOR_CLASSES")
+  const_set("INSPECTOR_CLASSES", [SpecdiffCustomInspector])
+
+  def format(object)
+    ::Specdiff.diff_inspect(object)
+  end
+end

data/lib/specdiff/version.rb

@@ -1,3 +1,3 @@
 module Specdiff
-  VERSION = "0.2.0"
+  VERSION = "0.3.0-rc1"
 end

data/lib/specdiff/webmock.rb

@@ -1 +1,41 @@
-require_relative "webmock/request_body_diff"
+require "hashdiff"
+require "json"
+
+module WebMock
+  class RequestBodyDiff
+    def initialize(request_signature, request_stub)
+      @request_signature = request_signature
+      @request_stub      = request_stub
+    end
+
+    PrettyPrintableThingy = Struct.new(:specdiff) do
+      # webmock does not print the diff if it responds true to this.
+      def empty?
+        specdiff.empty?
+      end
+
+      # webmock prints the diff by passing us to PP.pp, which in turn uses this
+      # method.
+      def pretty_print(pp)
+        pp.text("\r") # remove a space that isn't supposed to be there
+        pp.text(specdiff.to_s)
+      end
+    end
+
+    def body_diff
+      specdiff = Specdiff.diff(request_stub_body, request_signature.body)
+      PrettyPrintableThingy.new(specdiff)
+    end
+
+    attr_reader :request_signature, :request_stub
+    private :request_signature, :request_stub
+
+    private
+
+    def request_stub_body
+      request_stub.request_pattern &&
+        request_stub.request_pattern.body_pattern &&
+        request_stub.request_pattern.body_pattern.pattern
+    end
+  end
+end

data/lib/specdiff.rb

@@ -1,13 +1,27 @@
 require_relative "specdiff/version"
 require_relative "specdiff/config"
 require_relative "specdiff/colorize"
+require_relative "specdiff/inspect"
+require_relative "specdiff/hashprint"
 require_relative "specdiff/compare"
 
 module Specdiff
-  # Diff two things
+  # Compare two things, returns a Specdiff::Diff.
   def self.diff(...)
     ::Specdiff::Compare.call(...)
   end
+
+  # Use Specdiff's implementation for turning a nested hash/array structure
+  # into a string. Optimized for diff quality.
+  def self.hashprint(...)
+    ::Specdiff::Hashprint.call(...)
+  end
+
+  # Use Specdiff's inspect, which has some extra logic layered in for
+  # dates/time/bigdecimal. For most objects this just delegates to #inspect.
+  def self.diff_inspect(...)
+    ::Specdiff::Inspect.call(...)
+  end
 end
 
 require_relative "specdiff/diff"