diff_matcher 2.5.0 → 2.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2868c9df6fcb0629a3b11aa0ff612fec55d83c7e
-  data.tar.gz: db68ce3ce7834da9517bea0b7987537f3cbb3e85
+SHA256:
+  metadata.gz: a39a9962e5431cf3cbacda911c0154150733fd65510c5840ab9c67a87bb05991
+  data.tar.gz: 6b6cc7b445d393cbe1d2644de6b15ba78268e68f70b97934f8e1b4b868e29ec9
 SHA512:
-  metadata.gz: 57f3e4075c94f1ebf5f4ce3862df3c7ee6e32a39ee27eba9f37f65cd6d377686dfda4bcd8a62ae2a0379ad9780c11555dabc43e0e9faa03ea4aa190779c67c3f
-  data.tar.gz: 0f5752354f037eed868ccf50fab9c0e84c6593cb710effa098555c73aadc89327bd110cd30d5c2e64360dcf3a42020ab0ab985ae7633306f08a845e6ae30cc00
+  metadata.gz: 50f9c16a0a4f4012b8df6a79e2f2f1ac9133a565c7e8746949a4259ddd8a42bea14478f9423f26ed76abc6c6a1772ab78264576dd37d1497ca7cc9afc75c8a79
+  data.tar.gz: 89f284d344accf4a9aeb1d5b75cb20ab9466683601dd31d99d4b588325eaa7793d1a43c614ed33780078e285e7c3395108ad02386cc8a8ea8b6a101dde7b0c26

data/.travis.yml

@@ -5,8 +5,22 @@ rvm:
   - 1.9.2
   - 1.9.3
   - rbx
-#  - rbx-19mode
+  - rbx-19mode
+  - rbx-2
   - jruby
   - ree
-#  - ruby-head
   - 2.0.0
+  - 2.1
+  - 2.2
+  - 2.3.0
+  - ruby-head
+
+before_install:
+  - gem install bundler -v '1.11.2'
+
+matrix:
+  fast_finish: true
+  allow_failures:
+    - rvm: rbx
+    - rvm: rbx-19mode
+    - rvm: rbx-2

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+### v2.8.0
+
+* Add new diff-* executables for matching JSON & CSV files on the command line
+
+### v2.7.1
+
+* Use `failure_message` from RSpec matchers in diff output. (denyago)
+
+### v2.7.0
+
+* Add rspec custom matcher `be_json_matching` for Rspec v2.x & v3.x
+
+### v2.6.0
+
+* Add rspec custom matcher `be_matching` for RSpec v3.x
+
 ### v2.5.0
 
 * Add rspec custom matcher `be_matching`

data/README.md

@@ -5,21 +5,23 @@ DiffMatcher
 [![Gem Version](https://badge.fury.io/rb/diff_matcher.png)](http://badge.fury.io/rb/diff_matcher)
 [![Dependency Status](https://gemnasium.com/diff-matcher/diff_matcher.png)](https://gemnasium.com/diff-matcher/diff_matcher)
 [![still maintained](http://stillmaintained.com/diff-matcher/diff_matcher.png)](http://stillmaintained.com/diff-matcher/diff_matcher)
+[![diff_matcher API Documentation](https://www.omniref.com/ruby/gems/diff_matcher.png)](https://www.omniref.com/ruby/gems/diff_matcher)
 
 Generates a diff by matching against user-defined matchers written in ruby.
 
 DiffMatcher matches input data (eg. from a JSON API) against values,
-ranges, classes, regexes, procs, custom matchers and/or easily composed,
+ranges, classes, regexes, procs, custom matchers, RSpec matchers and/or easily composed,
 nested combinations thereof to produce an easy to read diff string.
 
 Actual input values are matched against expected matchers in the following way:
 
 ``` ruby
-actual.is_a? expected  # when expected is a class
-expected.match actual  # when expected is a regexp
-expected.call actual   # when expected is a proc
-actual == expected     # when expected is anything else
-expected.diff actual   # when expected is a built-in DiffMatcher
+actual.is_a? expected    # when expected is a class
+expected.match actual    # when expected is a regexp
+expected.call actual     # when expected is a proc
+expected.matches? actual # when expected implements an RSpec Matcher interface
+actual == expected       # when expected is anything else
+expected.diff actual     # when expected is a built-in DiffMatcher
 ```
 
 Using these building blocks, more complicated nested matchers can be
@@ -32,7 +34,7 @@ actual   = { :a=>{ :a1=>10, :a2=>12 }, :b=>[ 21     ], :c=>'3' , :d=>4     , :e=
 puts DiffMatcher::difference(expected, actual, :color_scheme=>:white_background)
 ```
 
-![example output](https://raw.github.com/playup/diff_matcher/master/doc/diff_matcher.gif)
+![example output](https://raw.github.com/diff-matcher/diff_matcher/master/doc/diff_matcher.gif)
 
 
 Installation
@@ -200,6 +202,43 @@ puts DiffMatcher::difference(expected, [1, 2.00, "3"])
 # => Where, - 1 missing, + 1 additional, | 2 match_matcher
 ```
 
+When `actual` is matched against some custom logic, an object with an RSpec Matcher
+interface can be used. (NB. `#mathches?(actual)`, `#description` and `#failure_message`
+methods must be implemented.)
+
+So you can use one of the RSpec matchers or you can implement your own.
+
+```ruby
+class BeAWeekend
+  def matches?(day)
+    @day = day
+    %w{Sat Sun}.include?(day)
+  end
+
+  def description
+    'be a weekend day'
+  end
+
+  def failure_message
+    "expected #{@day} to #{description}"
+  end
+end
+
+be_a_weekend = BeAWeekend.new
+puts DiffMatcher::difference(be_a_weekend, 'Mon')
+# => - expected Mon to be a weekend day+ "Mon"
+# => Where, - 1 missing, + 1 additional
+
+
+all_be_weekends = DiffMatcher::AllMatcher.new(be_a_weekend)
+puts DiffMatcher::difference(all_be_weekends, ['Sat', 'Mon'])
+# => [
+# =>   R "Sat" be a weekend day,
+# =>   - expected Mon to be a weekend day+ "Mon"
+# => ]
+# => Where, - 1 missing, + 1 additional, R 1 match_rspec
+```
+
 ### Matcher options
 
 Matcher options can be passed to `DiffMatcher::difference` or `DiffMatcher::Matcher#diff`
@@ -284,6 +323,7 @@ in the following way:
     match matcher => "| "
     match range   => ". "
     match proc    => "{ "
+    match rspec   => "R "
 
 
 #### Colours
@@ -300,6 +340,7 @@ Using the `:default` colour scheme items shown in a difference are coloured as f
     match matcher => blue
     match range   => cyan
     match proc    => cyan
+    match rspec   => cyan
 
 Other colour schemes, eg. `:color_scheme=>:white_background` will use different colour mappings.
 
@@ -355,42 +396,11 @@ do pattern matching and also looks like a good alternative to diff_matcher, it h
 
 Use with rspec
 ---
-To use with rspec, create a custom matcher. The following example matcher works with rspec-1.2.4 and up.
+To use with rspec, require it in `spec_helper.rb`
 
 ``` ruby
-require 'diff_matcher'
-
-# Uses the diff_matcher gem to provide advanced matching abilities, along with nice visual representation of the
-# diff between actual and expected. The functionality set is very helpful for comparing hashes.
-#
-# Usage examples:
-#  it { should be_matching(my_var) }
-#  it { should be_matching(my_var).with_options(ignore_additional: true) }
-#
-# Options: by default, color_enabled is controlled by Rspec, and quiet is set to true.
-RSpec::Matchers.define :be_matching do |expected|
-  match do |actual|
-    options = { :color_enabled => RSpec::configuration.color_enabled?, :quiet => true }.merge(@options || {})
-    @difference = DiffMatcher::Difference.new(expected, actual, options)
-    @difference.matching?
-  end
-
-  chain :with_options do |options|
-    @options = options
-  end
-
-  failure_message_for_should do |actual|
-    "diff is:\n" + @difference.to_s
-  end
-
-  failure_message_for_should_not do |actual|
-    "diff is:\n" + @difference.to_s
-  end
-
-  description do
-    "match via DiffMatcher #{expected}" + (@options.blank? ? '' : " with options: #{@options}")
-  end
-end
+require 'diff_matcher/rspec'   # for RSpec version < 3.0
+require 'diff_matcher/rspec_3' # for RSpec version >= 3.x
 ```
 
 And use it with:
@@ -427,6 +437,75 @@ Finished in 0.00601 seconds
 ```
 
 
+Comparing to built-in rspec matcher
+---
+RSpec 3 now has a built-in complex matcher:
+``` ruby
+RSpec.describe "a complex example" do
+  let(:response) {{person: {first_name: "Noel", last_name: "Rappin"},
+                  company: {name: "Table XI", url: "www.tablexi.com"}}}
+
+  it "gets the right response" do
+    expect(response).to match({
+      person: {first_name: "Avdi", last_name: "Grim"},
+      company: {name: "ShipRise", url: a_string_matching(/tablexi/)}
+    })
+  end
+end
+```
+
+With `--color` set, will result in:
+
+![built-in complex matcher](https://raw.github.com/diff-matcher/diff_matcher/master/doc/builtin_complex_matcher.png)
+
+
+But using `diff_matcher`:
+``` ruby
+require "diff_matcher/rspec_3"
+
+RSpec.describe "a complex example" do
+  let(:response) {{person: {first_name: "Noel", last_name: "Rappin"},
+                  company: {name: "Table XI", url: "www.tablexi.com"}}}
+
+  it "gets the right response" do
+    expect(response).to be_matching({
+      person: {first_name: "Avdi", last_name: "Grim"},
+      company: {name: "ShipRise", url: /tablexi/}
+    }).with_options(quiet: false)
+  end
+end
+```
+
+With `--color` set, will result in:
+
+![diff-matcher](https://raw.github.com/diff-matcher/diff_matcher/master/doc/diff_matcher.png)
+
+ie. by making these changes:
+``` diff
+--- more_tapas_spec.rb  2017-03-02 19:51:26.000000000 +1100
++++ even_more_tapas_spec.rb 2017-03-02 20:41:52.000000000 +1100
+@@ -1,11 +1,13 @@
++require "diff_matcher/rspec_3"
++
+ RSpec.describe "a complex example" do
+   let(:response) {{person: {first_name: "Noel", last_name: "Rappin"},
+                   company: {name: "Table XI", url: "www.tablexi.com"}}}
+
+   it "gets the right response" do
+-    expect(response).to match({
++    expect(response).to be_matching({
+       person: {first_name: "Avdi", last_name: "Grim"},
+-      company: {name: "ShipRise", url: a_string_matching(/tablexi/)}
+-    })
++      company: {name: "ShipRise", url: /tablexi/}
++    }).with_options(quiet: false)
+   end
+ end
+```
+
+NB. Its not as easy to see with RSpec's built-in complex matcher that the url actually matched in the above example.
+
+
 Contributing
 ---
 

data/TODO.txt

@@ -12,3 +12,7 @@ ie. by matching `actual` against an `expected` value/pattern/class/proc.
 Wed Dec 14 2011
 - underline
 - string diff
+
+
+Sat Nov 14 2020
+- add tests for exe/diff-* executables

data/diff_matcher.gemspec

@@ -22,4 +22,6 @@ EOF
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ["lib"]
+  s.bindir        = "exe"
+  s.executables   = s.files.grep(%r{^#{s.bindir}/}) { |f| File.basename(f) }
 end

data/doc/even_more_tapas_spec.rb

@@ -0,0 +1,13 @@
+require "diff_matcher/rspec_3"
+
+RSpec.describe "a complex example" do
+  let(:response) {{person: {first_name: "Noel", last_name: "Rappin"},
+                  company: {name: "Table XI", url: "www.tablexi.com"}}}
+
+  it "gets the right response" do
+    expect(response).to be_matching({
+      person: {first_name: "Avdi", last_name: "Grim"},
+      company: {name: "ShipRise", url: /tablexi/}
+    }).with_options(quiet: false)
+  end
+end

data/doc/more_tapas_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe "a complex example" do
+  let(:response) {{person: {first_name: "Noel", last_name: "Rappin"},
+                  company: {name: "Table XI", url: "www.tablexi.com"}}}
+
+  it "gets the right response" do
+    expect(response).to match({
+      person: {first_name: "Avdi", last_name: "Grim"},
+      company: {name: "ShipRise", url: a_string_matching(/tablexi/)}
+    })
+  end
+end

data/exe/diff-csv

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+# Given:
+#   --- languages-v1.tsv ---
+#   id	name	author	first_appeared	stable_release
+#   1	ruby	Yukihiro Matsumoto	1995	2.7.1
+#   2	python	Guido van Rossum	1991	3.9.0
+#   3	jq	Stephen Dolan	2013	1.6
+#   --- languages-v1.tsv ---
+#
+#   --- languages-v2.tsv ---
+#   id	name	author	first_appeared	stable_release
+#   1	ruby	Yukihiro Matsumoto	1995	2.7.2
+#   2	python	Guido van Rossum	1991	3.9.0
+#   3	jq	Stephen Dolan	2013	1.6
+#   --- languages-v2.tsv ---
+#
+# Examples:
+#   > diff-csv languages-v1.tsv languages-v2.tsv
+#   {
+#     1=>{
+#       "stable_release"=>- "2.7.1"+ "2.7.2"
+#     }
+#   }
+#   Where, - 1 missing, + 1 additional
+#
+#   > VERBOSE=1 diff-csv languages-v{1,2}.tsv
+#   {
+#     1=>{
+#       "name"=>"ruby",
+#       "author"=>"Yukihiro Matsumoto",
+#       "first_appeared"=>1995,
+#       "stable_release"=>- "2.7.1"+ "2.7.2"
+#     },
+#     2=>{
+#       "name"=>"python",
+#       "author"=>"Guido van Rossum",
+#       "first_appeared"=>1991,
+#       "stable_release"=>"3.9.0"
+#     },
+#     3=>{
+#       "name"=>"jq",
+#       "author"=>"Stephen Dolan",
+#       "first_appeared"=>2013,
+#       "stable_release"=>1.6
+#     }
+#   }
+#   Where, - 1 missing, + 1 additional
+#
+#   > KEY=name diff-csv languages-v{1,2}.tsv
+#   {
+#     "ruby"=>{
+#       "stable_release"=>- "2.7.1"+ "2.7.2"
+#     }
+#   }
+#   Where, - 1 missing, + 1 additional
+
+require 'csv'
+require 'diff_matcher/cli'
+
+COL_SEP=ENV.fetch("COL_SEP", "\t")
+KEY=ENV.fetch("KEY", "id")
+
+
+def fix_nulls(h)
+  h.each { |k, v| h[k] = (v == 'NULL' ? nil : v) }
+end
+
+def records(file, key=KEY, col_sep=COL_SEP)
+  CSV(file, col_sep: COL_SEP, headers: true, converters: :all).inject({}) do |h, row|
+    data = fix_nulls(row.to_hash)
+    h.update(data.delete(key)=> data)
+  end
+end
+
+DiffMatcher::CLI.diff(
+  records(File.open(ARGV[0])),
+  records(File.open(ARGV[1]))
+)

data/exe/diff-json

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'diff_matcher/cli'
+require 'json'
+
+DiffMatcher::CLI.diff(
+  JSON.parse(File.read(ARGV[-2])),
+  JSON.parse(File.read(ARGV[-1]))
+)

data/exe/diff-match

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require 'diff_matcher/cli'
+
+DiffMatcher::CLI.diff(
+  eval(File.read(ARGV[-2])),
+  eval(File.read(ARGV[-1]))
+)

data/exe/diff-match-json

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'diff_matcher/cli'
+require 'json'
+
+DiffMatcher::CLI.diff(
+  eval(File.read(ARGV[-2])),
+  JSON.parse(File.read(ARGV[-1]))
+)

data/exe/diff-mysql

@@ -0,0 +1,93 @@
+#!/bin/bash -e
+# Examples:
+#   # Show diff between the TABLES in two databases
+#   TABLES="languages" diff-mysql database1 database2
+#
+#   # Show diff between languages TABLES skipping any output containing 'python'
+#   FILTER_CMD='grep -v python' TABLES=languages diff-mysql database{1,2}
+#
+#   # Filter at the database level instead
+#   FILTER_SQL="WHERE languages.name = 'python'" TABLES=languages diff-mysql database{1,2}
+#
+set -eo pipefail
+
+DB_USERNAME=${DB_USERNAME:-root}
+DB_PASSWORD=${DB_PASSWORD:-password}
+DB_HOST=${DB_HOST:-localhost}
+
+MAX_ROW_COUNT=${MAX_ROW_COUNT:-100}
+SKIP=${SKIP:-messages}
+
+DB_NAME1=$1
+DB_NAME2=$2
+
+puts() { local color=$1; local prefix=$2; local msg=$3
+  echo -e "[$(date +%Y%m%d%H%M%S)] [${color};1m${prefix}:[${color}m $msg" 1>&2
+}
+
+info()    { local msg=$*; puts 34 INFO "$msg"   ; }
+success() { local msg=$*; puts 32 SUCCESS "$msg"; }
+error()   { local msg=$*; puts 31 ERROR "$msg"  ; }
+
+skip() { local name=$1
+  for skip_name in $SKIP; do
+    [ "$skip_name" == "$name" ] && return 0
+  done
+  return 1
+}
+
+do_mysql() { local db_name="$1"; shift
+  mysql "$@" --user="$DB_USERNAME" --password="$DB_PASSWORD" --host="$DB_HOST" "$db_name" 2> /dev/null
+}
+
+do_mysql_silent() { local db_name=$1
+  do_mysql "$db_name" --silent
+}
+
+tables() { local db_name=$1
+  info "Fetching table names from database $db_name (host '$DB_HOST') ..."
+  echo "show tables" |
+  do_mysql_silent "$db_name"
+}
+TABLES=${TABLES:-$(tables "$DB_NAME1")}
+
+count_rows() { local table=$1; local db_name=$2
+  echo "select count(id) from $table" |
+  do_mysql_silent "$db_name"
+}
+
+diff_cmd() {
+  #diff -u $@
+  COLOR_ENABLED=1 ${DIFF_CMD:-diff-csv} "$@"
+}
+
+filter_cmd() {
+  ${FILTER_CMD:-cat}
+}
+
+dump_table() { local table=$1; local db_name=$2
+  echo "$(echo 'SELECT *') FROM $table ${FILTER_SQL}" |
+  do_mysql "$db_name" |
+  filter_cmd
+}
+
+table_diff() { local table="$1"
+  info "Diffing $table ($DB_NAME1 vs $DB_NAME2)"
+  diff_cmd <(dump_table "$table" {"$DB_NAME1","$DB_NAME2"})
+}
+
+
+exit_code=0
+for table in $TABLES; do
+  row_count=$(count_rows "$table" "$DB_NAME1")
+  if [ $row_count -lt $MAX_ROW_COUNT ]; then
+    if skip "$table"; then
+      info "Skipping $table (as it was referenced in SKIP)"
+    else
+      table_diff "$table" || exit_code=$?
+    fi
+  else
+    info "Skipping $table (as row count exceeds MAX_ROW_COUNT, $row_count > $MAX_ROW_COUNT)"
+  fi
+done
+exit $exit_code

data/lib/diff_matcher/cli.rb

@@ -0,0 +1,19 @@
+require 'diff_matcher'
+
+module DiffMatcher
+  module CLI
+    def self.diff(expected, actual, opts={})
+      # TODO maybe parse opts from command line instead of ENV vars...
+      diff_opts = {
+        color_enabled: true,
+        ignore_additional: ENV['IGNORE_ADDITIONAL'],
+        quiet: !ENV['VERBOSE']
+      }
+
+      if (diff_string = DiffMatcher.difference(expected, actual, diff_opts))
+        puts diff_string
+        exit 1
+      end
+    end
+  end
+end

data/lib/diff_matcher/difference.rb

@@ -88,7 +88,8 @@ module DiffMatcher
         :match_class   => [BLUE  , ":"],
         :match_matcher => [BLUE  , "|"],
         :match_range   => [CYAN  , "."],
-        :match_proc    => [CYAN  , "{"]
+        :match_proc    => [CYAN  , "{"],
+        :match_rspec   => [CYAN  , "R"]
     }
 
     class << self
@@ -186,7 +187,7 @@ module DiffMatcher
       @matches_shown ||= lambda {
         ret = []
         unless @quiet
-          ret += [:match_matcher, :match_class, :match_range, :match_proc, :match_regexp]
+          ret += [:match_matcher, :match_class, :match_range, :match_proc, :match_regexp, :match_rspec]
           ret += [:match_value]
         end
         ret
@@ -273,7 +274,12 @@ module DiffMatcher
         when Range  ; [expected.include?(actual)                      , :match_range  ]
         when Proc   ; [expected.call(actual)                          , :match_proc   ]
         when Regexp ; [actual.is_a?(String) && actual.match(expected) , :match_regexp ]
-        else          [actual == expected                             , :match_value  ]
+        else
+          if expected.respond_to?(:matches?)
+            [expected.matches?(actual), :match_rspec]
+          else
+            [actual == expected, :match_value]
+          end
       end
     end
 
@@ -294,6 +300,7 @@ module DiffMatcher
 
     def match_to_s(expected, actual, match_type)
       actual = match_regexp_to_s(expected, actual) if match_type == :match_regexp
+      actual = "#{actual} #{expected.description}" if match_type == :match_rspec
       markup(match_type, actual) if matches_shown.include?(match_type)
     end
 
@@ -308,6 +315,16 @@ module DiffMatcher
       end
     end
 
+    def summarize_rspec_matcher(matcher)
+      if matcher.respond_to?(:failure_message)
+        matcher.failure_message
+      elsif matcher.respond_to?(:failure_message_for_should)
+        matcher.failure_message_for_should
+      else
+        summarize_item(matcher)
+      end
+    end
+
     def difference_to_s(expected, actual)
       match, match_type, d = match?(expected, actual)
       if match
@@ -316,6 +333,8 @@ module DiffMatcher
         case match_type
         when :match_matcher
           d
+        when :match_rspec
+          "#{markup(:missing, summarize_rspec_matcher(expected))}#{markup(:additional, summarize_item(actual))}"
         else
           exp, act = if [expected, actual].any? { |item| item.is_a?(Proc) }
             [expected, actual].map { |item| item.inspect }

data/lib/diff_matcher/rspec.rb

@@ -1,3 +1,3 @@
 require 'rspec/core'
 require 'diff_matcher'
-require 'diff_matcher/rspec/matchers/diff_matcher'
+require 'diff_matcher/rspec/matchers'

data/lib/diff_matcher/rspec/matchers.rb

@@ -0,0 +1,3 @@
+require 'diff_matcher/rspec/matchers/diff_matcher'
+require 'diff_matcher/rspec/matchers/diff_json_matcher'
+

data/lib/diff_matcher/rspec/matchers/diff_json_matcher.rb

@@ -0,0 +1,31 @@
+# Uses the diff_matcher gem to provide advanced matching abilities, along with nice visual representation of the
+# diff between JSON.parse(actual) and expected. The functionality set is very helpful for comparing hashes.
+#
+# Usage examples:
+#  it { should be_matching(my_var) }
+#  it { should be_matching(my_var).with_options(ignore_additional: true) }
+#
+# Options: by default, color_enabled is controlled by Rspec, and quiet is set to true.
+RSpec::Matchers.define :be_json_matching do |expected|
+  match do |actual|
+    options = { :color_enabled => RSpec::configuration.color_enabled?, :quiet => true }.merge(@options || {})
+    @difference = DiffMatcher::Difference.new(expected, JSON.parse(actual), options)
+    @difference.matching?
+  end
+
+  chain :with_options do |options|
+    @options = options
+  end
+
+  failure_message_for_should do |actual|
+    "diff is:\n" + @difference.to_s
+  end
+
+  failure_message_for_should_not do |actual|
+    "diff is:\n" + @difference.to_s
+  end
+
+  description do
+    "match via DiffMatcher #{expected}" + (@options.blank? ? '' : " with options: #{@options}")
+  end
+end

data/lib/diff_matcher/rspec/matchers/diff_matcher.rb

@@ -1,15 +1,15 @@
 # Uses the diff_matcher gem to provide advanced matching abilities, along with nice visual representation of the
-# diff between actual and expected. The functionality set is very helpful for comparing hashes.
+# diff between JSON.parse(actual) and expected. The functionality set is very helpful for comparing hashes.
 #
 # Usage examples:
 #  it { should be_matching(my_var) }
 #  it { should be_matching(my_var).with_options(ignore_additional: true) }
 #
 # Options: by default, color_enabled is controlled by Rspec, and quiet is set to true.
-RSpec::Matchers.define :be_matching do |expected|
+RSpec::Matchers.define :be_json_matching do |expected|
   match do |actual|
     options = { :color_enabled => RSpec::configuration.color_enabled?, :quiet => true }.merge(@options || {})
-    @difference = DiffMatcher::Difference.new(expected, actual, options)
+    @difference = DiffMatcher::Difference.new(expected, JSON.parse(actual), options)
     @difference.matching?
   end
 

data/lib/diff_matcher/rspec_3.rb

@@ -0,0 +1,3 @@
+require 'rspec/core'
+require 'diff_matcher'
+require 'diff_matcher/rspec_3/matchers'

data/lib/diff_matcher/rspec_3/matchers.rb

@@ -0,0 +1,2 @@
+require 'diff_matcher/rspec_3/matchers/diff_matcher'
+require 'diff_matcher/rspec_3/matchers/diff_json_matcher'

data/lib/diff_matcher/rspec_3/matchers/diff_json_matcher.rb

@@ -0,0 +1,31 @@
+# Uses the diff_matcher gem to provide advanced matching abilities, along with nice visual representation of the
+# diff between JSON.parse(actual) and expected. The functionality set is very helpful for comparing hashes.
+#
+# Usage examples:
+#  it { should be_matching(my_var) }
+#  it { should be_matching(my_var).with_options(ignore_additional: true) }
+#
+# Options: by default, color_enabled is controlled by Rspec, and quiet is set to true.
+RSpec::Matchers.define :be_json_matching do |expected|
+  match do |actual|
+    options = { :color_enabled => RSpec::configuration.color_enabled?, :quiet => true }.merge(@options || {})
+    @difference = DiffMatcher::Difference.new(expected, JSON.parse(actual), options)
+    @difference.matching?
+  end
+
+  chain :with_options do |options|
+    @options = options
+  end
+
+  failure_message do |actual|
+    "diff is:\n" + @difference.to_s
+  end
+
+  failure_message_when_negated do |actual|
+    "diff is:\n" + @difference.to_s
+  end
+
+  description do
+    "match via DiffMatcher #{expected}" + (@options.blank? ? '' : " with options: #{@options}")
+  end
+end

data/lib/diff_matcher/rspec_3/matchers/diff_matcher.rb

@@ -0,0 +1,31 @@
+# Uses the diff_matcher gem to provide advanced matching abilities, along with nice visual representation of the
+# diff between actual and expected. The functionality set is very helpful for comparing hashes.
+#
+# Usage examples:
+#  it { should be_matching(my_var) }
+#  it { should be_matching(my_var).with_options(ignore_additional: true) }
+#
+# Options: by default, color_enabled is controlled by Rspec, and quiet is set to true.
+RSpec::Matchers.define :be_matching do |expected|
+  match do |actual|
+    options = { :color_enabled => RSpec::configuration.color_enabled?, :quiet => true }.merge(@options || {})
+    @difference = DiffMatcher::Difference.new(expected, actual, options)
+    @difference.matching?
+  end
+
+  chain :with_options do |options|
+    @options = options
+  end
+
+  failure_message do |actual|
+    "diff is:\n" + @difference.to_s
+  end
+
+  failure_message_when_negated do |actual|
+    "diff is:\n" + @difference.to_s
+  end
+
+  description do
+    "match via DiffMatcher #{expected}" + (@options.blank? ? '' : " with options: #{@options}")
+  end
+end

data/lib/diff_matcher/version.rb

@@ -1,3 +1,3 @@
 module DiffMatcher
-  VERSION = "2.5.0"
+  VERSION = "2.8.1"
 end

data/spec/diff_matcher/difference_spec.rb

@@ -470,6 +470,36 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
       end
     end
 
+    context 'a duck-type responding to #matches?' do
+      matchable = Class.new do
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          actual == @expected
+        end
+
+        def failure_message
+          "the matcher should be eq '#{@expected}'"
+        end
+
+        def description
+          "be eq #{@expected}"
+        end
+      end
+      expected, same, different =
+        matchable.new('foo'),
+        'foo',
+        'bar'
+
+      it_behaves_like "a diff matcher", expected, same, different,
+        <<-EOF
+        - the matcher should be eq 'foo'+ "bar"
+        Where, - 1 missing, + 1 additional
+        EOF
+    end
+
     context "a proc," do
       expected, same, different =
         lambda { |x| [FalseClass, TrueClass].include? x.class },
@@ -654,12 +684,25 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
   end
 
   context "when expected has multiple items," do
+    matchable = Class.new do
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def matches?(actual)
+        actual == @expected
+      end
+
+      def description
+        "be == #{@expected}"
+      end
+    end
     expected, same, different =
-      [ 1,  2, /\d/, Fixnum, 4..6 , lambda { |x| x % 6 == 0 } ],
-      [ 1,  2, "3" , 4     , 5    , 6                         ],
-      [ 0,  2, "3" , 4     , 5    , 6                         ]
+      [ 1,  2, /\d/, Fixnum, 4..6 , lambda { |x| x % 6 == 0 }, matchable.new(7)],
+      [ 1,  2, "3" , 4     , 5    , 6                        , 7               ],
+      [ 0,  2, "3" , 4     , 5    , 6                        , 7               ]
 
-    describe "it shows regex, class, range, proc matches and matches" do
+    describe "it shows regex, class, range, proc matches, matches and RSpec matcher" do
       it_behaves_like "a diff matcher", expected, same, different,
         <<-EOF
         [
@@ -668,9 +711,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           ~ "(3)",
           : 4,
           . 5,
-          { 6
+          { 6,
+          R 7 be == 7
         ]
-        Where, - 1 missing, + 1 additional, ~ 1 match_regexp, : 1 match_class, . 1 match_range, { 1 match_proc
+        Where, - 1 missing, + 1 additional, ~ 1 match_regexp, : 1 match_class, . 1 match_range, { 1 match_proc, R 1 match_rspec
         EOF
     end
 
@@ -693,9 +737,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           ~ "(3)",
           : 4,
           . 5,
-          { 6
+          { 6,
+          R 7 be == 7
         ]
-        Where, - 1 missing, + 1 additional, ~ 1 match_regexp, : 1 match_class, . 1 match_range, { 1 match_proc
+        Where, - 1 missing, + 1 additional, ~ 1 match_regexp, : 1 match_class, . 1 match_range, { 1 match_proc, R 1 match_rspec
         EOF
     end
 
@@ -708,9 +753,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
         \e[0m  \e[32m~ \e[0m"\e[32m(\e[1m3\e[0m\e[32m)\e[0m"\e[0m,
         \e[0m  \e[34m: \e[1m4\e[0m,
         \e[0m  \e[36m. \e[1m5\e[0m,
-        \e[0m  \e[36m{ \e[1m6\e[0m
+        \e[0m  \e[36m{ \e[1m6\e[0m,
+        \e[0m  \e[36mR \e[1m7 be == 7\e[0m
         \e[0m]
-        Where, \e[31m- \e[1m1 missing\e[0m, \e[33m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m
+        Where, \e[31m- \e[1m1 missing\e[0m, \e[33m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m, \e[36mR \e[1m1 match_rspec\e[0m
         EOF
 
       context "on a white background" do
@@ -722,9 +768,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           \e[0m  \e[32m~ \e[0m"\e[32m(\e[1m3\e[0m\e[32m)\e[0m"\e[0m,
           \e[0m  \e[34m: \e[1m4\e[0m,
           \e[0m  \e[36m. \e[1m5\e[0m,
-          \e[0m  \e[36m{ \e[1m6\e[0m
+          \e[0m  \e[36m{ \e[1m6\e[0m,
+          \e[0m  \e[36mR \e[1m7 be == 7\e[0m
           \e[0m]
-          Where, \e[31m- \e[1m1 missing\e[0m, \e[35m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m
+          Where, \e[31m- \e[1m1 missing\e[0m, \e[35m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m, \e[36mR \e[1m1 match_rspec\e[0m
           EOF
       end
 
@@ -739,9 +786,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           \e[0m  \e[32m~ \e[0m"\e[32m(\e[1m3\e[0m\e[32m)\e[0m"\e[0m,
           \e[0m  \e[34m: \e[1m4\e[0m,
           \e[0m  \e[36m. \e[1m5\e[0m,
-          \e[0m  \e[36m{ \e[1m6\e[0m
+          \e[0m  \e[36m{ \e[1m6\e[0m,
+          \e[0m  \e[36mR \e[1m7 be == 7\e[0m
           \e[0m]
-          Where, \e[31m- \e[1m1 missing\e[0m, \e[33m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m
+          Where, \e[31m- \e[1m1 missing\e[0m, \e[33m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m, \e[36mR \e[1m1 match_rspec\e[0m
           EOF
       end
 
@@ -756,9 +804,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           \e[0m  \e[32m~ \e[0m"\e[32m(\e[1m3\e[0m\e[32m)\e[0m"\e[0m,
           \e[0m  \e[34m: \e[1m4\e[0m,
           \e[0m  \e[36m. \e[1m5\e[0m,
-          \e[0m  \e[36m{ \e[1m6\e[0m
+          \e[0m  \e[36m{ \e[1m6\e[0m,
+          \e[0m  \e[36mR \e[1m7 be == 7\e[0m
           \e[0m]
-          Where, \e[31m- \e[1m1 missing\e[0m, \e[35m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m
+          Where, \e[31m- \e[1m1 missing\e[0m, \e[35m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m, \e[36mR \e[1m1 match_rspec\e[0m
           EOF
       end
     end
@@ -778,9 +827,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
         \e[0m  \e[32m~ \e[0m"\e[32m(\e[1m3\e[0m\e[32m)\e[0m"\e[0m,
         \e[0m  \e[34m: \e[1m4\e[0m,
         \e[0m  \e[36m. \e[1m5\e[0m,
-        \e[0m  \e[36m{ \e[1m6\e[0m
+        \e[0m  \e[36m{ \e[1m6\e[0m,
+        \e[0m  \e[36mR \e[1m7 be == 7\e[0m
         \e[0m]
-        Where, \e[31m- \e[1m1 missing\e[0m, \e[35m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m
+        Where, \e[31m- \e[1m1 missing\e[0m, \e[35m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m, \e[36mR \e[1m1 match_rspec\e[0m
         EOF
     end
 
@@ -794,9 +844,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           <span style=\"color:green\">~ </b></span>\"<span style=\"color:green\">(<b>3</b></span><span style=\"color:green\">)</b></span>\"</b></span>,
           <span style=\"color:blue\">: <b>4</b></span>,
           <span style=\"color:cyan\">. <b>5</b></span>,
-          <span style=\"color:cyan\">{ <b>6</b></span>
+          <span style=\"color:cyan\">{ <b>6</b></span>,
+          <span style=\"color:cyan\">R <b>7 be == 7</b></span>
         ]
-        Where, <span style=\"color:red\">- <b>1 missing</b></span>, <span style=\"color:magenta\">+ <b>1 additional</b></span>, <span style=\"color:green\">~ <b>1 match_regexp</b></span>, <span style=\"color:blue\">: <b>1 match_class</b></span>, <span style=\"color:cyan\">. <b>1 match_range</b></span>, <span style=\"color:cyan\">{ <b>1 match_proc</b></span>
+        Where, <span style=\"color:red\">- <b>1 missing</b></span>, <span style=\"color:magenta\">+ <b>1 additional</b></span>, <span style=\"color:green\">~ <b>1 match_regexp</b></span>, <span style=\"color:blue\">: <b>1 match_class</b></span>, <span style=\"color:cyan\">. <b>1 match_range</b></span>, <span style=\"color:cyan\">{ <b>1 match_proc</b></span>, <span style=\"color:cyan\">R <b>1 match_rspec</b></span>
         </pre>
         EOF
     end

data/spec/diff_matcher/rspec/matchers/diff_matcher_spec.rb

@@ -3,6 +3,7 @@ require 'diff_matcher/rspec'
 
 describe :be_matching do
   it "should call DiffMatcher::Difference" do
+    pending 'how are custom matchers tested now?'
     DiffMatcher::Difference.should_receive(:new).with(
       :expected, :actual, { :color_enabled => RSpec::configuration.color_enabled?, :quiet => true }.merge({ :foo => 'bar' })
     ).and_return(double(:matching? => true))

metadata

@@ -1,40 +1,61 @@
 --- !ruby/object:Gem::Specification
 name: diff_matcher
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.8.1
 platform: ruby
 authors:
 - locochris
-autorequire: 
-bindir: bin
+autorequire:
+bindir: exe
 cert_chain: []
-date: 2013-07-29 00:00:00.000000000 Z
+date: 2020-11-15 00:00:00.000000000 Z
 dependencies: []
 description: |
   DiffMatcher matches input data (eg. from a JSON API) against values,
   ranges, classes, regexes, procs, custom matchers and/or easily composed,
   nested combinations thereof to produce an easy to read diff string.
 email: chris@locomote.com.au
-executables: []
+executables:
+- diff-csv
+- diff-json
+- diff-match
+- diff-match-json
+- diff-mysql
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
 - TODO.txt
 - diff_matcher.gemspec
+- doc/builtin_complex_matcher.png
 - doc/diff_matcher.gif
+- doc/diff_matcher.png
+- doc/even_more_tapas_spec.rb
 - doc/example_output.png
+- doc/more_tapas_spec.rb
+- exe/diff-csv
+- exe/diff-json
+- exe/diff-match
+- exe/diff-match-json
+- exe/diff-mysql
 - lib/diff_matcher.rb
+- lib/diff_matcher/cli.rb
 - lib/diff_matcher/difference.rb
 - lib/diff_matcher/escape_to_html.rb
 - lib/diff_matcher/rspec.rb
+- lib/diff_matcher/rspec/matchers.rb
+- lib/diff_matcher/rspec/matchers/diff_json_matcher.rb
 - lib/diff_matcher/rspec/matchers/diff_matcher.rb
+- lib/diff_matcher/rspec_3.rb
+- lib/diff_matcher/rspec_3/matchers.rb
+- lib/diff_matcher/rspec_3/matchers/diff_json_matcher.rb
+- lib/diff_matcher/rspec_3/matchers/diff_matcher.rb
 - lib/diff_matcher/version.rb
 - spec/diff_matcher/difference_spec.rb
 - spec/diff_matcher/rspec/matchers/diff_matcher_spec.rb
@@ -44,24 +65,23 @@ licenses:
 - BSD
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Generates a diff by matching against user-defined matchers written in ruby.
 test_files: