specdiff 0.3.0.pre.rc1 → 0.3.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68cf98631e494fb5f016c0b3632cce58f616dad54ba11c782b37e3de4f2b36c9
-  data.tar.gz: b97fee8a8e586b383a71bf0dcdcb32be7cf1c135356a90ec2ae7488fc2082071
+  metadata.gz: 8a33e470568352bc5fb3079f5aa3cf9933f5c02d7e28aae98847b9165a0d6a86
+  data.tar.gz: ad35a03f7da4fee967890515447eb0d2a2a4ec927d78d2458198177166aa43c6
 SHA512:
-  metadata.gz: b374cadd1aa564cf8252c4b3d6c4ca2be952b147891cdbec9f0799383349bf5bcf61a1ef94979bc2b1f7dbe4d850e586d4c11f1271c74a14dc9be09cffc4e184
-  data.tar.gz: 8379b0c263ae20900ec31b63ea9600e3c15cef8fe9b597c1e1349a708c323d03ee8bfaa46d6f6eeb666e2af0ee751e7ef2cd47917e927eeceb48a7f076a1e126
+  metadata.gz: 6fa7b514db6ccb4a7216f317184e6de0dae0fb8ad762222c4d09ee589300ae4d71a38549710ceb8191e5276958fcdfc27e65dcb50f0353e64065492c58a28b8a
+  data.tar.gz: bf66592a0f9d787058dcdd3b27910863abdc70cdeb177ddfb84d6ddfa9973adee345fa8c90f821f6a8dbab94898db375414eeef8e9a306b532b9aa472f615280

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# local installed gem bundles, ala node_modules for npm
+.gem-bundle/

data/CHANGELOG.md

@@ -7,7 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.3.0-rc1]
+## [0.3.0.rc2] - 2024-04-05
+
+### Changed
+
+- Rework how hashdiff's output gets printed.
+- Rework switching heuristic between text diff/hashdiff in hash differ.
+
+### Fixed
+
+- The RSpec integration now inspects hashes and arrays recursively. (Like rspec does by default)
+- RSpec integration no longer breaks description output of matchers when using multi matchers (like .all or .and)
+- The hash differ now deals with recursive hashes and arrays
+- RSpec integration no longer breaks description output of matchers that are part of a diff inside an array or hash. (like when doing `match([have_attributes(...)])`)
+
+## [0.3.0-rc1] - 2024-04-02
 
 ### Added
 

data/README.md

@@ -134,6 +134,7 @@ High level description of the heuristic specdiff implements
   - [ ] unit tests are passing (`$ bundle exec rake test`)
   - [ ] linter is happy (`$ bundle exec rake lint`)
   - [ ] `examples/` look good
+  - [ ] check the package size using `$ bundle exec inspect_build`, make sure you haven't added any large files by accident
   - [ ] update the version number in `version.rb`
   - [ ] make sure the `examples/` `Gemfile.lock` files are updated (run bundle install)
   - [ ] make sure `Gemfile.lock` is updated (run bundle install)
@@ -142,8 +143,6 @@ High level description of the heuristic specdiff implements
   - [ ] make sure the pipeline is green
   - [ ] `$ bundle exec rake release`
 
-To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/odinhb/specdiff.

data/lib/specdiff/compare.rb

@@ -80,9 +80,9 @@ private
     elsif a.type == :text && b.type == :text
       Specdiff::Differ::Text
     elsif a.type == :hash && b.type == :hash
-      Specdiff::Differ::Hashdiff
+      Specdiff::Differ::Hash
     elsif a.type == :array && b.type == :array
-      Specdiff::Differ::Hashdiff
+      Specdiff::Differ::Hash
     else
       Specdiff::Differ::NotFound
     end

data/lib/specdiff/diff.rb

@@ -19,12 +19,15 @@
   end
 
   def inspect
-    if empty?
-      "<Specdiff::Diff (empty)>"
-    elsif raw.respond_to?(:bytesize)
-      "<Specdiff::Diff w/ #{raw&.bytesize || 0} bytes of #raw diff>"
-    else
-      "<Specdiff::Diff #{raw.inspect}>"
-    end
+    raw_diff = if empty?
+                 "empty"
+               elsif differ == ::Specdiff::Differ::Text
+                 bytes = raw&.bytesize || 0
+                 "#{bytes} bytes of #raw diff"
+               else
+                 "#{raw.inspect}"
+               end
+
+    "<Specdiff::Diff (#{a.type}/#{b.type}) (#{differ}) (#{raw_diff})>"
   end
 end

data/lib/specdiff/differ/{hashdiff.rb → hash.rb}

@@ -1,12 +1,15 @@
 require "hashdiff"
 
-class Specdiff::Differ::Hashdiff
+class Specdiff::Differ::Hash
   extend ::Specdiff::Colorize
 
-  VALUE_CHANGE_PERCENTAGE_THRESHOLD = 0.2
-  TOTAL_CHANGES_FOR_GROUPING_THRESHOLD = 9
+  # The percentage of changes that must (potentially) be a key rename in a hash
+  # for text diffing to kick in. Expressed as a fraction of 1.
+  KEY_CHANGE_PERCENTAGE_THRESHOLD = 0.8
 
-  NEWLINE = "\n"
+  # The number of changes that must be detected by hashdiff before we print some
+  # extra newlines to better group extra/missing/new_values visually.
+  TOTAL_CHANGES_FOR_GROUPING_THRESHOLD = 9
 
   def self.diff(a, b)
     # array_path: true returns the path as an array, which differentiates
@@ -24,54 +27,60 @@ class Specdiff::Differ::Hashdiff
 
     change_percentage = _calculate_change_percentage(hashdiff_diff)
 
-    if change_percentage >= VALUE_CHANGE_PERCENTAGE_THRESHOLD
+    if change_percentage <= KEY_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)
+      text_diff = ::Specdiff.diff(a_text, b_text)
 
-      if diff.empty?
+      if text_diff.empty?
         []
       else
-        diff.a.type = a.type
-        diff.b.type = b.type
-
-        diff
+        text_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] == "-" }
+    extra_keys = hashdiff_diff.count { |element| element[0] == "+" }
+    missing_keys = hashdiff_diff.count { |element| element[0] == "-" }
+    new_values = 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
+    # puts "extra_keys: #{extra_keys.inspect}"
+    # puts "missing_keys: #{missing_keys.inspect}"
+    # puts "new_values: #{new_values.inspect}"
+
+    potential_changed_keys = [extra_keys, missing_keys].min
+    adjusted_extra_keys = extra_keys - potential_changed_keys
+    adjusted_missing_keys = missing_keys - potential_changed_keys
+    # puts "potential_changed_keys: #{potential_changed_keys.inspect}"
+    # puts "adjusted_extra_keys: #{adjusted_extra_keys.inspect}"
+    # puts "adjusted_missing_keys: #{adjusted_missing_keys.inspect}"
+
+    non_changed_keys = adjusted_extra_keys + adjusted_missing_keys + new_values
+    total_changes = non_changed_keys + potential_changed_keys
+    # puts "non_changed_keys: #{non_changed_keys.inspect}"
+    # puts "total_changes: #{total_changes.inspect}"
+
+    key_change_fraction = Rational(potential_changed_keys, total_changes)
+    key_change_percentage = key_change_fraction.to_f
+    # puts "key_change_fraction: #{key_change_fraction.inspect}"
+    # puts "key_change_percentage: #{key_change_percentage.inspect}"
+
+    key_change_percentage
   end
 
   def self.empty?(diff)
     diff.raw.empty?
   end
 
+  NEWLINE = "\n"
+
   def self.stringify(diff)
     result = +""
+    return result if diff.empty?
 
     total_changes = diff.raw.size
     group_with_newlines = total_changes >= TOTAL_CHANGES_FOR_GROUPING_THRESHOLD
@@ -92,6 +101,9 @@ class Specdiff::Differ::Hashdiff
     additions = changes_grouped_by_type["+"] || []
     value_changes = changes_grouped_by_type["~"] || []
 
+    result << "@@ +#{additions.size}/-#{deletions.size}/~#{value_changes.size} @@"
+    result << NEWLINE
+
     deletions.each do |change|
       value = change[2]
       path = _stringify_path(change[1])
@@ -108,7 +120,7 @@ class Specdiff::Differ::Hashdiff
       value = change[2]
       path = _stringify_path(change[1])
 
-      result << "    new key: #{path} (#{::Specdiff.diff_inspect(value)})"
+      result << "  extra key: #{path} (#{::Specdiff.diff_inspect(value)})"
       result << NEWLINE
     end
 
@@ -123,17 +135,19 @@ class Specdiff::Differ::Hashdiff
 
       from_inspected = ::Specdiff.diff_inspect(from)
       to_inspected = ::Specdiff.diff_inspect(to)
-      result << "changed key: #{path} (#{from_inspected} -> #{to_inspected})"
+      result << "  new value: #{path} (#{from_inspected} -> #{to_inspected})"
       result << NEWLINE
     end
 
     colorize_by_line(result) do |line|
       if line.start_with?("missing key:")
         red(line)
-      elsif line.start_with?(/\s+new key:/)
+      elsif line.start_with?("  extra key:")
         green(line)
-      elsif line.start_with?("changed key:")
+      elsif line.start_with?("  new value:")
         yellow(line)
+      elsif line.start_with?("@@")
+        cyan(line)
       else
         reset_color(line)
       end

data/lib/specdiff/differ.rb

@@ -4,4 +4,4 @@ end
 # require only the builtin differs, plugins are optionally loaded later
 require_relative "differ/not_found"
 require_relative "differ/text"
-require_relative "differ/hashdiff"
+require_relative "differ/hash"

data/lib/specdiff/hashprint.rb

@@ -13,6 +13,7 @@ class Specdiff::Hashprint
   NEWLINE = "\n".freeze
 
   def call(thing)
+    @recursion_trail = []
     @indentation_level = 0
     @indentation_per_level = SPACE * INDENTATION_SPACES
     @indent = ""
@@ -41,17 +42,6 @@ private
     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
 
@@ -67,11 +57,24 @@ private
     end
   end
 
+  def track_recursion(thing)
+    @recursion_trail.push(thing)
+    result = yield
+    @recursion_trail.pop
+    result
+  end
+
+  def deja_vu?(current_place)
+    @recursion_trail.any? { |previous_place| previous_place == current_place }
+  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
+    if deja_vu?(thing)
+      output_deja_vu(thing)
+    elsif Hash === thing
       output_hash(thing)
     elsif Array === thing
       output_array(thing)
@@ -89,10 +92,10 @@ private
     @output << @indent unless this_indent_should_be_skipped
 
     @output << HASH_OPEN
-    # unless hash.empty?
-      @output << NEWLINE
+    @output << NEWLINE
 
-      increase_indentation
+    increase_indentation
+    track_recursion(hash) do
       hash.each do |key, value|
         @output << @indent
 
@@ -113,11 +116,10 @@ private
         @output << COMMA
         @output << NEWLINE
       end
-      decrease_indentation
-
-      @output << @indent
-    # end
+    end
+    decrease_indentation
 
+    @output << @indent
     @output << HASH_CLOSE
   end
 
@@ -128,21 +130,19 @@ private
     @output << @indent unless this_indent_should_be_skipped
 
     @output << ARRAY_OPEN
+    @output << NEWLINE
 
-    # unless array.empty?
-      @output << NEWLINE
-
-      increase_indentation
+    increase_indentation
+    track_recursion(array) do
       array.each do |element|
         output(element)
         @output << COMMA
         @output << NEWLINE
       end
-      decrease_indentation
-
-      @output << @indent
-    # end
+    end
+    decrease_indentation
 
+    @output << @indent
     @output << ARRAY_CLOSE
   end
 
@@ -151,4 +151,24 @@ private
 
     @output << ::Specdiff.diff_inspect(thing)
   end
+
+  # The stdlib inspect code returns this when you have recursive structures.
+  STANDARD_INSPECT_RECURSIVE_ARRAY = "[...]".freeze
+  STANDARD_INSPECT_RECURSIVE_HASH = "{...}".freeze
+
+  def output_deja_vu(thing)
+    @output << @indent unless this_indent_should_be_skipped
+
+    case thing
+    when Array
+      # "#<Array ##{thing.object_id}>"
+      @output << STANDARD_INSPECT_RECURSIVE_ARRAY
+    when Hash
+      # "#<Hash ##{thing.object_id}>"
+      @output << STANDARD_INSPECT_RECURSIVE_HASH
+    else
+      # this should never happen
+      raise "Specdiff::Hashprint missing deja vu for: #{thing.inspect}"
+    end
+  end
 end

data/lib/specdiff/inspect.rb

@@ -6,11 +6,17 @@ class Specdiff::Inspect
     new.call(...)
   end
 
+  def initialize
+    @recursion_trail = []
+  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
+    if Hash === thing || Array === thing
+      recursive_replace_inspect(thing).inspect
+    elsif Time === thing
       "#<Time: #{thing.strftime(TIME_FORMAT)}>"
     elsif DateTime === thing
       "#<DateTime: #{thing.rfc3339}>"
@@ -18,6 +24,12 @@ class Specdiff::Inspect
       "#<Date: #{thing.strftime(DATE_FORMAT)}>"
     elsif defined?(BigDecimal) && BigDecimal === thing
       "#<BigDecimal: #{thing.to_s('F')}>"
+    elsif rspec_matcher?(thing)
+      # Turns out rspec depends on the recursion in its inspection logic to
+      # print the "description" of rspec matchers, in situations such as when
+      # using multi-matchers (.all, .or or .and), or when nesting them inside
+      # eachother (such as match([have_attributes(...)])).
+      thing.description
     else
       begin
         thing.inspect
@@ -27,6 +39,12 @@ class Specdiff::Inspect
     end
   end
 
+  private def rspec_matcher?(thing)
+    defined?(::Specdiff::RSpecIntegration) &&
+      ::RSpec::Support.is_a_matcher?(thing) &&
+      thing.respond_to?(:description)
+  end
+
   private def inspect_anyway(uninspectable)
     "#<uninspectable #{class_of(uninspectable)}>"
   end
@@ -38,4 +56,79 @@ class Specdiff::Inspect
     singleton_class.ancestors
       .find { |ancestor| !ancestor.equal?(singleton_class) }
   end
+
+  # recursion below
+
+  InspectWrapper = Struct.new(:text) do
+    def inspect
+      text
+    end
+  end
+
+  private def recursive_replace_inspect(thing)
+    if deja_vu?(thing)
+      # I've just been in this place before
+      # And I know it's my time to go...
+      return InspectWrapper.new(inspect_deja_vu(thing))
+    end
+
+    case thing
+    when Array
+      track_recursion(thing) do
+        thing.map { |element| recursive_replace_inspect(element) }
+      end
+    when Hash
+      track_recursion(thing) do
+        new_hash = {}
+
+        thing.each do |key, value|
+          new_hash[recursive_replace_inspect(key)] = recursive_replace_inspect(value)
+        end
+
+        new_hash
+      end
+    else
+      wrap_inspect(thing)
+    end
+  rescue SystemStackError => e
+    wrap_inspect(
+      thing,
+      text: "#{e.class}: #{e.message}\n\n" \
+            "encountered when inspecting #{thing.inspect}"
+    )
+  end
+
+  private def track_recursion(thing)
+    @recursion_trail.push(thing)
+    result = yield
+    @recursion_trail.pop
+    result
+  end
+
+  private def deja_vu?(current_place)
+    @recursion_trail.any? { |previous_place| previous_place == current_place }
+  end
+
+  private def wrap_inspect(thing, text: :_use_diff_inspect)
+    text = call(thing) if text == :_use_diff_inspect
+    InspectWrapper.new(text)
+  end
+
+  # The stdlib inspect code returns this when you have recursive structures.
+  STANDARD_INSPECT_RECURSIVE_ARRAY = "[...]".freeze
+  STANDARD_INSPECT_RECURSIVE_HASH = "{...}".freeze
+
+  private def inspect_deja_vu(thing)
+    case thing
+    when Array
+      # "#<Array ##{thing.object_id}>"
+      STANDARD_INSPECT_RECURSIVE_ARRAY
+    when Hash
+      # "#<Hash ##{thing.object_id}>"
+      STANDARD_INSPECT_RECURSIVE_HASH
+    else
+      # this should never happen
+      raise "Specdiff::Inspect missing deja vu for: #{thing.inspect}"
+    end
+  end
 end

data/lib/specdiff/rspec.rb

@@ -1,3 +1,6 @@
+raise "rspec must be required before specdiff/rspec!" unless defined?(RSpec)
+raise "RSpec::Support is missing????" unless defined?(RSpec::Support)
+
 class RSpec::Support::Differ
   alias old_diff diff
 
@@ -14,20 +17,10 @@ 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
+
+# marker for successfully loading this integration
+class Specdiff::RSpecIntegration; end # rubocop: disable Lint/EmptyClass

data/lib/specdiff/version.rb

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

data/lib/specdiff/webmock.rb

@@ -1,5 +1,4 @@
-require "hashdiff"
-require "json"
+raise "webmock must be required before specdiff/webmock" unless defined?(WebMock)
 
 module WebMock
   class RequestBodyDiff
@@ -39,3 +38,6 @@ module WebMock
     end
   end
 end
+
+# marker for successfully loading this integration
+class Specdiff::WebmockIntegration; end # rubocop: disable Lint/EmptyClass

data/specdiff.gemspec

@@ -17,13 +17,12 @@ Gem::Specification.new do |spec|
   spec.metadata["source_code_uri"] = spec.homepage
   spec.metadata["changelog_uri"] = "#{spec.homepage}/CHANGELOG.md"
 
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
-    end
-  end
+  spec.files =
+    Dir["*.gemspec"] +
+    Dir["*.md"] +
+    Dir["*.txt"] +
+    Dir[".gitignore"] +
+    Dir["lib/**/*.rb"]
   spec.require_paths = ["lib"]
 
   spec.add_dependency "hashdiff", "~> 1.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: specdiff
 version: !ruby/object:Gem::Version
-  version: 0.3.0.pre.rc1
+  version: 0.3.0.rc2
 platform: ruby
 authors:
 - Odin Heggvold Bekkelund
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-02 00:00:00.000000000 Z
+date: 2024-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashdiff
@@ -45,26 +45,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".rubocop.yml"
-- ".tool-versions"
+- ".gitignore"
 - CHANGELOG.md
-- Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
-- Rakefile
-- assets/webmock_json_with_specdiff.png
-- assets/webmock_text_with_specdiff.png
-- examples/rspec/.rspec
-- examples/rspec/Gemfile
-- examples/rspec/Gemfile.lock
-- examples/rspec/spec/example_spec.rb
-- examples/rspec/spec/spec_helper.rb
-- examples/webmock/Gemfile
-- examples/webmock/Gemfile.lock
-- examples/webmock/json.rb
-- examples/webmock/text.rb
 - glossary.txt
 - lib/specdiff.rb
 - lib/specdiff/colorize.rb
@@ -72,7 +56,7 @@ files:
 - lib/specdiff/config.rb
 - lib/specdiff/diff.rb
 - lib/specdiff/differ.rb
-- lib/specdiff/differ/hashdiff.rb
+- lib/specdiff/differ/hash.rb
 - lib/specdiff/differ/not_found.rb
 - lib/specdiff/differ/text.rb
 - lib/specdiff/hashprint.rb

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper