specdiff 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7da7ac63f4638bd752f83ff41a27488757e43e57c028891d4fd944afd03f58ca
+  data.tar.gz: d5a49e6aeb3525a454df920aa7d1b541a0812ffb9f8d0e1813a4bc05b57b006f
+SHA512:
+  metadata.gz: 38ae83cd45a69892ca6d22915e0b253447eb12f42165a7673751abbb3993381702a02771ad3181a96d26204e6d171268a14423e85c2323a345df243be918f5a5
+  data.tar.gz: f44ce432951f3e2198ed6c4ed4cfc975b4eb201ced235791cd917c2476ca7a60fcb4ce0aff023fd4423f97b7eee2819d395d514b970188a5bc232ce89ee44ea6

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,203 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+require:
+  - rubocop-rspec
+  - rubocop-rake
+
+##
+# LAYOUT COPS
+##
+
+Layout:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: true
+  Max: 120
+
+Layout/SpaceInsideBlockBraces:
+  Enabled: true
+  EnforcedStyle: space
+  SpaceBeforeBlockParameters: no_space
+Layout/SpaceInsideHashLiteralBraces:
+  Enabled: true
+  EnforcedStyle: no_space
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: true
+  EnforcedStyle: indented
+
+##
+# STYLE COPS
+##
+
+Style:
+  Enabled: false
+
+Style/TrailingCommaInArrayLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/SpecialGlobalVars:
+  Enabled: true
+  EnforcedStyle: use_english_names
+
+##
+# NAMING COPS
+##
+
+Naming/BlockForwarding: # new in 1.24
+  Enabled: false
+Naming/MethodParameterName:
+  Enabled: false
+
+##
+# SECURITY COPS
+##
+
+Security/CompoundHash: # new in 1.28
+  Enabled: true
+Security/IoMethods: # new in 1.22
+  Enabled: true
+
+##
+# LINT COPS
+##
+
+Lint/SuppressedException:
+  AllowComments: true
+Lint/AmbiguousAssignment: # new in 1.7
+  Enabled: true
+Lint/AmbiguousOperatorPrecedence: # new in 1.21
+  Enabled: true
+Lint/AmbiguousRange: # new in 1.19
+  Enabled: true
+Lint/ConstantOverwrittenInRescue: # new in 1.31
+  Enabled: true
+Lint/DeprecatedConstants: # new in 1.8
+  Enabled: true
+Lint/DuplicateBranch: # new in 1.3
+  Enabled: true
+  IgnoreLiteralBranches: true
+  IgnoreConstantBranches: true
+Lint/DuplicateMagicComment: # new in 1.37
+  Enabled: true
+Lint/DuplicateMatchPattern: # new in 1.50
+  Enabled: true
+Lint/DuplicateRegexpCharacterClassElement: # new in 1.1
+  Enabled: true
+Lint/EmptyBlock: # new in 1.1
+  Enabled: true
+Lint/EmptyClass: # new in 1.3
+  Enabled: true
+Lint/EmptyInPattern: # new in 1.16
+  Enabled: true
+Lint/IncompatibleIoSelectWithFiberScheduler: # new in 1.21
+  Enabled: true
+Lint/LambdaWithoutLiteralBlock: # new in 1.8
+  Enabled: true
+Lint/MixedCaseRange: # new in 1.53
+  Enabled: true
+Lint/NoReturnInBeginEndBlocks: # new in 1.2
+  Enabled: true
+Lint/NonAtomicFileOperation: # new in 1.31
+  Enabled: true
+Lint/NumberedParameterAssignment: # new in 1.9
+  Enabled: true
+Lint/OrAssignmentToConstant: # new in 1.9
+  Enabled: true
+Lint/RedundantDirGlobSort: # new in 1.8
+  Enabled: true
+Lint/RedundantRegexpQuantifiers: # new in 1.53
+  Enabled: true
+Lint/RefinementImportMethods: # new in 1.27
+  Enabled: true
+Lint/RequireRangeParentheses: # new in 1.32
+  Enabled: true
+Lint/RequireRelativeSelfPath: # new in 1.22
+  Enabled: true
+Lint/SymbolConversion: # new in 1.9
+  Enabled: true
+Lint/ToEnumArguments: # new in 1.1
+  Enabled: true
+Lint/TripleQuotes: # new in 1.9
+  Enabled: true
+Lint/UnexpectedBlockArity: # new in 1.5
+  Enabled: true
+Lint/UnmodifiedReduceAccumulator: # new in 1.1
+  Enabled: true
+Lint/UselessRescue: # new in 1.43
+  Enabled: true
+Lint/UselessRuby2Keywords: # new in 1.23
+  Enabled: true
+
+##
+# METRICS COPS
+##
+
+Metrics:
+  Enabled: false
+
+##
+# GEMSPEC COPS
+##
+
+Gemspec/DeprecatedAttributeAssignment: # new in 1.30
+  Enabled: true
+Gemspec/DevelopmentDependencies: # new in 1.44
+  Enabled: true
+Gemspec/RequireMFA: # new in 1.23
+  Enabled: false
+Gemspec/OrderedDependencies:
+  Enabled: false
+
+##
+# BUNDLER COPS
+##
+
+Bundler/OrderedGems:
+  Enabled: false
+
+##
+# RSPEC COPS
+##
+
+# documentation can be found in
+# http://www.rubydoc.info/gems/rubocop-rspec/RuboCop/Cop/RSpec/<name>
+RSpec:
+  Enabled: false
+
+RSpec/HookArgument:
+  Enabled: true
+  EnforcedStyle: each
+RSpec/MessageSpies:
+  Enabled: true
+  EnforcedStyle: receive
+
+##
+# CAPYBARA COPS
+##
+
+# cant remember installing capybara but whatever
+Capybara:
+  Enabled: false
+
+##
+# FACTORYBOT COPS
+##
+
+# cant remember installing factorybot but whatever
+FactoryBot:
+  Enabled: false
+
+##
+# RAKE COPS
+##
+
+Rake:
+  Enabled: true

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.2.2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-11-30
+
+- Initial release

data/Gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in specdiff.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "rubocop", "~> 1.21"
+gem "rubocop-rspec", '~> 2.25'
+gem 'rubocop-rake', '~> 0.6.0'

data/Gemfile.lock

@@ -0,0 +1,76 @@
+PATH
+  remote: .
+  specs:
+    specdiff (0.1.0)
+      diff-lcs (~> 1.5)
+      hashdiff (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    diff-lcs (1.5.0)
+    hashdiff (1.0.1)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    parallel (1.23.0)
+    parser (3.2.2.4)
+      ast (~> 2.4.1)
+      racc
+    racc (1.7.3)
+    rainbow (3.1.1)
+    rake (13.1.0)
+    regexp_parser (2.8.2)
+    rexml (3.2.6)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.6)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.1)
+    rubocop (1.57.2)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.4)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.30.0)
+      parser (>= 3.2.1.0)
+    rubocop-capybara (2.19.0)
+      rubocop (~> 1.41)
+    rubocop-factory_bot (2.24.0)
+      rubocop (~> 1.33)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    rubocop-rspec (2.25.0)
+      rubocop (~> 1.40)
+      rubocop-capybara (~> 2.17)
+      rubocop-factory_bot (~> 2.22)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (2.5.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.21)
+  rubocop-rake (~> 0.6.0)
+  rubocop-rspec (~> 2.25)
+  specdiff!
+
+BUNDLED WITH
+   2.3.5

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Odin H B
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,84 @@
+# Specdiff
+
+A gem for improving diff output in webmock.
+
+Webmock currently has a somewhat hidden feature where it will produce a diff
+between a request body and a registered stub when making an unregistered request
+if they happen to both be json (including setting content type). This gem aims
+to bring text diffing (ala rspec) to webmock via monkey-patch, as well as
+dropping the content type requirement.
+
+Specdiff automagically detects the types of provided data and prints a suitable
+diff between them.
+
+Check out the examples directory to see what it might look like.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "specdiff", require: false
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install specdiff
+
+## Usage
+
+Put the following in your `spec_helper.rb`. (Or equivalent initializer
+for test environment) You probably don't want to load/use this gem in a release
+environment.
+
+```rb
+# spec_helper.rb
+
+require "specdiff"
+require "specdiff/webmock" # optional, webmock patches
+
+# optionally, you can turn off terminal colors
+Specdiff.configure do |config|
+  config.colorize = true
+end
+```
+
+The webmock patch should make webmock show diffs from the specdiff gem when
+stubs mismatch.
+
+### Direct usage
+
+You can also use the gem directly:
+
+```rb
+diff = Specdiff.diff(something, and_something_else)
+
+diff.empty? # => true/false, if it is empty you might want to not print the diff, it is probably useless
+diff.to_s # => a string for showing to a developer who may or may not be scratching their head
+```
+
+## Development
+
+Install the software versions specified in `.tool-versions`.
+
+Run `bin/setup` to install dependencies. Then, run `bundle exec rake` to run the tests and linter and make sure they're green before starting to make your changes.
+
+Run `bundle exec rake -AD` gor a full list of all the available tasks you may use for development purposes.
+
+You can also run `bin/console` for an interactive prompt that will allow you to experiment with the gem code loaded.
+
+## Releasing
+
+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.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:test)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new(:lint)
+
+task default: %i[test lint]

data/examples/webmock/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem "specdiff", require: false, path: "../../"
+
+gem "webmock", require: false
+gem "http"

data/examples/webmock/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: ../..
+  specs:
+    specdiff (0.1.0)
+      diff-lcs (~> 1.5)
+      hashdiff (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.5)
+      public_suffix (>= 2.0.2, < 6.0)
+    crack (0.4.5)
+      rexml
+    diff-lcs (1.5.0)
+    domain_name (0.6.20231109)
+    ffi (1.16.3)
+    ffi-compiler (1.0.1)
+      ffi (>= 1.0.0)
+      rake
+    hashdiff (1.0.1)
+    http (5.1.1)
+      addressable (~> 2.8)
+      http-cookie (~> 1.0)
+      http-form_data (~> 2.2)
+      llhttp-ffi (~> 0.4.0)
+    http-cookie (1.0.5)
+      domain_name (~> 0.5)
+    http-form_data (2.3.0)
+    llhttp-ffi (0.4.0)
+      ffi-compiler (~> 1.0)
+      rake (~> 13.0)
+    public_suffix (5.0.4)
+    rake (13.1.0)
+    rexml (3.2.6)
+    webmock (3.19.1)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  http
+  specdiff!
+  webmock
+
+BUNDLED WITH
+   2.3.5

data/examples/webmock/json.rb

@@ -0,0 +1,37 @@
+require "webmock"
+require "specdiff"
+require "specdiff/webmock"
+
+Specdiff.load!(:json)
+
+include WebMock::API
+
+WebMock.enable!
+WebMock.show_body_diff! # on by default
+
+stub_request(:post, "https://www.example.com")
+  .with(
+    body: JSON.generate({
+      my_hash: "is great",
+      the_hash: "is amazing",
+    })
+  )
+  .to_return(status: 400, body: "hello")
+
+begin
+  HTTP.post(
+    "https://www.example.com",
+    body: JSON.generate({
+      i_had_to_go: "and post a different hash",
+      my_hash: "is different",
+    }),
+  )
+rescue WebMock::NetConnectNotAllowedError => e
+  puts "success! webmock stopped the request"
+  puts "here is the error text:\n\n"
+
+  puts e.message
+  exit 0
+end
+
+puts "nothing was raised??"

data/examples/webmock/text.rb

@@ -0,0 +1,39 @@
+require "webmock"
+require "specdiff"
+require "specdiff/webmock"
+
+include WebMock::API
+
+WebMock.enable!
+WebMock.show_body_diff! # on by default
+
+stub_request(:post, "https://www.example.com")
+  .with(
+    body: <<~TEXT1,
+      this is the expected body
+      that you should send
+      nothing less
+      nothing more
+    TEXT1
+  )
+  .to_return(status: 400, body: "hello")
+
+begin
+  HTTP.post(
+    "https://www.example.com",
+    body: <<~TEXT2,
+      this is the unexpected body
+      that i should not have sent
+      nothing less
+      nothing more
+    TEXT2
+  )
+rescue WebMock::NetConnectNotAllowedError => e
+  puts "success! webmock stopped the request"
+  puts "here is the error text:\n\n"
+
+  puts e.message
+  exit 0
+end
+
+puts "nothing was raised??"

data/glossary.txt

@@ -0,0 +1,24 @@
+diff
+  the return value from the Specdiff::diff method.
+  this is not the direct return value from a plugin/differ, that is the
+  "raw diff" (or diff.raw)
+
+differ
+  a class responding to ::diff(a, b) and ::stringify(diff) able to produce a
+  human-comprehensible diff output for your terminal
+
+plugin
+  external differ (responding to more methods), able to be provided by third
+  parties or end users themselves
+
+type
+  a symbol like :text, :json or :hash which denotes the type of data in a way
+  which is useful for picking a differ
+
+  :text
+    a string which likely contains plaintext data of some kind
+
+side
+  an object containing either side of a comparison that needs to be made
+  when defining a plugin, the diff method receives two sides: a, b
+  most importantly, a side contains a value and a type

data/lib/specdiff/colorize.rb

@@ -0,0 +1,31 @@
+module Specdiff::Colorize
+  module_function
+
+  def colorize_by_line(string, line_separator = "\n")
+    return string if !::Specdiff.config.colorize?
+
+    string.lines(line_separator).map do |line|
+      yield(line)
+    end.join
+  end
+
+  def reset_color(text)
+    "\e[0m#{text}"
+  end
+
+  def red(text)
+    "\e[31m#{text}\e[0m"
+  end
+
+  def green(text)
+    "\e[32m#{text}\e[0m"
+  end
+
+  def yellow(text)
+    "\e[33m#{text}\e[0m"
+  end
+
+  def blue(text)
+    "\e[34m#{text}\e[0m"
+  end
+end

data/lib/specdiff/config.rb

@@ -0,0 +1,27 @@
+module Specdiff
+  Config = Struct.new(:colorize, keyword_init: true) do
+    def colorize?
+      colorize
+    end
+  end
+
+  # Read the configuration
+  def self.config
+    threadlocal[:config] ||= default_configuration
+  end
+
+  # private, used for testing
+  def self._set_config(new_config)
+    threadlocal[:config] = new_config
+  end
+
+  # Set the configuration
+  def self.configure
+    yield(config)
+  end
+
+  # Generates the default configuration
+  def self.default_configuration
+    Config.new(colorize: true)
+  end
+end

data/lib/specdiff/diff.rb

@@ -0,0 +1,27 @@
+::Specdiff::Diff = Struct.new(
+  :differ, :a, :b, :raw, keyword_init: true,
+) do
+  def differ_id
+    differ.id
+  end
+
+  def to_s
+    differ.stringify(self)
+  end
+
+  def empty?
+    differ == ::Specdiff::Differ::NotFound
+  end
+
+  def types
+    [a.type, b.type]
+  end
+
+  def inspect
+    if empty?
+      "<Specdiff::Diff (empty)>"
+    else
+      "<Specdiff::Diff w/ #{raw&.bytesize || 0} bytes of #raw diff>"
+    end
+  end
+end

data/lib/specdiff/differ/hashdiff.rb

@@ -0,0 +1,85 @@
+require "hashdiff"
+require "pp"
+
+class Specdiff::Differ::Hashdiff
+  extend ::Specdiff::Colorize
+
+  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(
+      a.value, b.value,
+      array_path: true,
+      use_lcs: false,
+    )
+  end
+
+  def self.stringify(diff)
+    diff.raw.pretty_inspect
+
+    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)
+
+      if type == "+"
+        value = change[2]
+
+        result << "added #{path2} with value #{value.inspect}"
+      elsif type == "-"
+        value = change[2]
+
+        result << "removed #{path2} with value #{value.inspect}"
+      elsif type == "~"
+        from = change[2]
+        to = change[3]
+
+        result << "changed #{path2} from #{from.inspect} to #{to.inspect}"
+      else
+        result << change.inspect
+      end
+
+      result << "\n"
+    end
+
+    colorize_by_line(result) do |line|
+      if line.start_with?("removed")
+        red(line)
+      elsif line.start_with?("added")
+        green(line)
+      elsif line.start_with?("changed")
+        yellow(line)
+      else
+        reset_color(line)
+      end
+    end
+  end
+
+  PATH_SEPARATOR = ".".freeze
+
+  def self._stringify_path(path)
+    result = +""
+
+    path.each do |component|
+      if component.is_a?(Numeric)
+        result.chomp!(PATH_SEPARATOR)
+        result << "[#{component}]"
+      elsif component.is_a?(Symbol)
+        # by not inspecting symbols they look prettier than strings, but you
+        # can still tell the difference in the printed output
+        result << component.to_s
+      else
+        result << component.inspect
+      end
+
+      result << PATH_SEPARATOR
+    end
+
+    result.chomp(PATH_SEPARATOR)
+  end
+end

data/lib/specdiff/differ/not_found.rb

@@ -0,0 +1,24 @@
+# this is the null differ
+class Specdiff::Differ::NotFound
+  def self.diff(a, b)
+    comparison = "!="
+    comparison = "=" if a.value == b.value
+
+    a_representation = _representation_for(a)
+    b_representation = _representation_for(b)
+
+    "#{a_representation} #{comparison} #{b_representation}"
+  end
+
+  def self._representation_for(side)
+    if side.type == :binary
+      "<binary content>"
+    else
+      side.value.inspect
+    end
+  end
+
+  def self.stringify(diff)
+    diff.raw
+  end
+end

data/lib/specdiff/differ/text.rb

@@ -0,0 +1,73 @@
+require "diff/lcs"
+require "diff/lcs/hunk"
+
+class Specdiff::Differ::Text
+  extend ::Specdiff::Colorize
+
+  NEWLINE = "\n".freeze
+  CONTEXT_LINES = 3
+
+  # this implementation is based on RSpec::Support::Differ
+  # https://github.com/rspec/rspec-support/blob/main/lib/rspec/support/differ.rb
+  # and also the hunk generator it uses
+  def self.diff(a, b)
+    a_value = a.value
+    b_value = b.value
+
+    if a_value.encoding != b_value.encoding
+      return <<~MSG
+        Strings have different encodings:
+          #{a.value.encoding.inspect} != #{b.value.encoding.inspect}
+      MSG
+    end
+
+    diff = ""
+
+    a_lines = a_value.split(NEWLINE).map! { _1.chomp }
+    b_lines = b_value.split(NEWLINE).map! { _1.chomp }
+    hunks = ::Diff::LCS.diff(a_lines, b_lines).map do |piece|
+      ::Diff::LCS::Hunk.new(
+        a_lines, b_lines, piece, CONTEXT_LINES, 0,
+      )
+    end
+
+    hunks.each_cons(2) do |prev_hunk, current_hunk|
+      begin
+        if current_hunk.overlaps?(prev_hunk)
+          current_hunk.merge(prev_hunk)
+        else
+          diff << prev_hunk.diff(:unified).to_s
+        end
+      ensure
+        diff << NEWLINE
+      end
+    end
+
+    if hunks.last
+      diff << hunks.last.diff(:unified).to_s
+    end
+
+    diff << "\n"
+
+    return colorize_by_line(diff) do |line|
+      case line[0].chr
+      when "+"
+        green(line)
+      when "-"
+        red(line)
+      when "@"
+        if line[1].chr == "@"
+          blue(line)
+        else
+          reset_color(line)
+        end
+      else
+        reset_color(line)
+      end
+    end
+  end
+
+  def self.stringify(diff)
+    diff.raw
+  end
+end

data/lib/specdiff/differ.rb

@@ -0,0 +1,100 @@
+class Specdiff::Differ
+  Side = Struct.new(:value, :type, keyword_init: true)
+
+  def self.call(...)
+    new.call(...)
+  end
+
+  def call(raw_a, raw_b)
+    a = parse_side(raw_a)
+    b = parse_side(raw_b)
+
+    if a.type == :text && b.type == :binary
+      new_b = try_reencode(b.value, a.value.encoding)
+      if new_b
+        b = b.dup
+        b.type = :text
+        b.value = new_b
+      end
+    elsif a.type == :binary && b.type == :text
+      new_a = try_reencode(a.value, b.value.encoding)
+      if new_a
+        a = a.dup
+        a.type = :text
+        a.value = new_a
+      end
+    end
+
+    differ = pick_differ(a, b)
+    raw = differ.diff(a, b)
+
+    if raw.is_a?(::Specdiff::Diff) # detect recursive plugins, such as json
+      raw
+    else
+      ::Specdiff::Diff.new(raw: raw, differ: differ, a: a, b: b)
+    end
+  end
+
+private
+
+  def parse_side(raw_value)
+    type = detect_type(raw_value)
+
+    Side.new(value: raw_value, type: type)
+  end
+
+  def detect_type(thing)
+    if (type = detect_plugin_types(thing))
+      type
+    elsif thing.is_a?(Hash)
+      :hash
+    elsif thing.is_a?(Array)
+      :array
+    elsif thing.is_a?(String) && thing.encoding == Encoding::BINARY
+      :binary
+    elsif thing.is_a?(String)
+      :text
+    elsif thing.nil?
+      :nil
+    else
+      :unknown
+    end
+  end
+
+  def detect_plugin_types(thing)
+    Specdiff.plugins
+      .filter { |plugin| plugin.respond_to?(:detect_type) }
+      .detect { |plugin| plugin.detect_type(thing) }
+      &.id
+  end
+
+  def try_reencode(binary_string, target_encoding)
+    binary_string.encode(target_encoding)
+  rescue StandardError
+    nil
+  end
+
+  def pick_differ(a, b)
+    if (differ = pick_plugin_differ(a, b))
+      differ
+    elsif a.type == :text && b.type == :text
+      Specdiff::Differ::Text
+    elsif a.type == :hash && b.type == :hash
+      Specdiff::Differ::Hashdiff
+    elsif a.type == :array && b.type == :array
+      Specdiff::Differ::Hashdiff
+    else
+      Specdiff::Differ::NotFound
+    end
+  end
+
+  def pick_plugin_differ(a, b)
+    Specdiff.plugins
+      .detect { |plugin| plugin.compatible?(a, b) }
+  end
+end
+
+# require only the builtin differs, plugins are optionally loaded later
+require_relative "differ/not_found"
+require_relative "differ/text"
+require_relative "differ/hashdiff"

data/lib/specdiff/plugin.rb

@@ -0,0 +1,11 @@
+module Specdiff::Plugin
+  module ClassMethods
+    def compatible?(a, b)
+      a.type == id && b.type == id
+    end
+  end
+
+  def self.included(plugin)
+    plugin.extend(ClassMethods)
+  end
+end

data/lib/specdiff/plugins/json.rb

@@ -0,0 +1,42 @@
+require "json"
+
+class Specdiff::Plugins::Json
+  include ::Specdiff::Plugin
+
+  def self.id
+    :json
+  end
+
+  def self.detect_type(thing)
+    thing.is_a?(String) && _json_parsable?(thing)
+  end
+
+  def self._json_parsable?(thing)
+    return false unless thing.is_a?(String)
+
+    JSON.parse(thing)
+    true
+  rescue JSON::ParserError
+    false
+  end
+
+  def self.compatible?(a, b)
+    a.type == :json || b.type == :json
+  end
+
+  def self.diff(a, b)
+    a_value = a.value
+    b_value = b.value
+
+    a_value = JSON.parse(a_value) if a.type == :json
+    b_value = JSON.parse(b_value) if b.type == :json
+
+    ::Specdiff.diff(a_value, b_value)
+  end
+
+  def self.stringify(_diff)
+    # since we recurse back into Specdiff, we don't need to stringify in this
+    # plugin. the built in hash/array/text differs should do the stringification
+    raise "#{self.class}::stringify was called, this should never happen"
+  end
+end

data/lib/specdiff/plugins.rb

@@ -0,0 +1,73 @@
+module Specdiff
+  THREADLOCAL_PLUGINS_KEY = :__specdiff_plugins
+
+  def self.plugins
+    threadlocal[THREADLOCAL_PLUGINS_KEY]
+  end
+
+  BUILTIN_PLUGINS = %i[json]
+  BUILTIN_TYPES = %i[hash array binary text nil]
+
+  # Load extra type support, such as support for json strings
+  def self.load!(*plugins)
+    return if plugins.size == 0
+
+    plugins.each do |new_plugin|
+      if BUILTIN_PLUGINS.include?(new_plugin)
+        case new_plugin
+        when :json
+          require "#{__dir__}/plugins/json"
+          load_plugin_class!(::Specdiff::Plugins::Json)
+        end
+      else
+        load_plugin_class!(new_plugin)
+      end
+    end
+
+    nil
+  end
+
+  PLUGIN_INTERFACE = [:id, :detect_type, :compatible?, :diff, :stringify].freeze
+
+  # Load a single plugin class, does not support symbols for builtin plugins.
+  def self.load_plugin_class!(plugin)
+    plugin_interface = PLUGIN_INTERFACE
+
+    if plugin.respond_to?(:id)
+      if BUILTIN_TYPES.include?(plugin.id)
+        plugin_interface = PLUGIN_INTERFACE - [:detect_type]
+      end
+
+      if plugin.id == :unknown
+        raise <<~MSG
+          plugin #{plugin.inspect} defined #id to = :unknown, but this is not \
+          allowed because it would undermine the utility of the #empty? method \
+          on the diff.
+        MSG
+      end
+    end
+
+    missing = plugin_interface.filter do |method_name|
+      !plugin.respond_to?(method_name)
+    end
+
+    if missing.any?
+      raise <<~MSG
+        plugin #{plugin.inspect} does not respond to required methods:
+        these are required: #{plugin_interface}
+        these were missing: #{missing.inspect}
+      MSG
+    end
+
+    ::Specdiff.plugins << plugin
+  end
+
+  # private
+  def self._clear_plugins!
+    threadlocal[THREADLOCAL_PLUGINS_KEY] = []
+  end
+  _clear_plugins!
+
+  module Plugins
+  end
+end

data/lib/specdiff/threadlocal.rb

@@ -0,0 +1,8 @@
+module Specdiff
+  THREADLOCAL_KEY = :__specdiff_threadlocals
+
+  def self.threadlocal
+    Thread.current.thread_variable_get(THREADLOCAL_KEY) ||
+      Thread.current.thread_variable_set(THREADLOCAL_KEY, {})
+  end
+end

data/lib/specdiff/version.rb

@@ -0,0 +1,3 @@
+module Specdiff
+  VERSION = "0.1.0"
+end

data/lib/specdiff/webmock/request_body_diff.rb

@@ -0,0 +1,41 @@
+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/webmock.rb

@@ -0,0 +1 @@
+require_relative "webmock/request_body_diff"

data/lib/specdiff.rb

@@ -0,0 +1,16 @@
+require_relative "specdiff/version"
+require_relative "specdiff/threadlocal"
+require_relative "specdiff/config"
+require_relative "specdiff/colorize"
+
+module Specdiff
+  # Diff two things
+  def self.diff(...)
+    ::Specdiff::Differ.call(...)
+  end
+end
+
+require_relative "specdiff/diff"
+require_relative "specdiff/differ"
+require_relative "specdiff/plugin"
+require_relative "specdiff/plugins"

data/specdiff.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "lib/specdiff/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "specdiff"
+  spec.version = Specdiff::VERSION
+  spec.authors = ["Odin Heggvold Bekkelund"]
+  spec.email = ["odinhb@protonmail.com"]
+
+  spec.summary = "Improved request body diffs for webmock"
+  spec.homepage = "https://github.com/odinhb/specdiff"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  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.require_paths = ["lib"]
+
+  spec.add_dependency "hashdiff", "~> 1.0"
+  spec.add_dependency "diff-lcs", "~> 1.5"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: specdiff
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Odin Heggvold Bekkelund
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashdiff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: diff-lcs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: 
+email:
+- odinhb@protonmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".tool-versions"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/webmock/Gemfile
+- examples/webmock/Gemfile.lock
+- examples/webmock/json.rb
+- examples/webmock/text.rb
+- glossary.txt
+- lib/specdiff.rb
+- lib/specdiff/colorize.rb
+- lib/specdiff/config.rb
+- lib/specdiff/diff.rb
+- lib/specdiff/differ.rb
+- lib/specdiff/differ/hashdiff.rb
+- lib/specdiff/differ/not_found.rb
+- lib/specdiff/differ/text.rb
+- lib/specdiff/plugin.rb
+- lib/specdiff/plugins.rb
+- lib/specdiff/plugins/json.rb
+- lib/specdiff/threadlocal.rb
+- lib/specdiff/version.rb
+- lib/specdiff/webmock.rb
+- lib/specdiff/webmock/request_body_diff.rb
+- specdiff.gemspec
+homepage: https://github.com/odinhb/specdiff
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/odinhb/specdiff
+  source_code_uri: https://github.com/odinhb/specdiff
+  changelog_uri: https://github.com/odinhb/specdiff/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: Improved request body diffs for webmock
+test_files: []