rspec-resembles_json_matchers 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 67063b7a2b5685ac47e58408e3eb9ab2556ebb9c
-  data.tar.gz: 2bda36618f32e3b751c36274eb8f69cb790d4e2a
+SHA256:
+  metadata.gz: 41ce9ddec87f87a2b3bbdca185b9987b6b61c89813c1e1a4b5a23f5af677d636
+  data.tar.gz: 1f04f3a51ffd0c508a551661946466f1910eb22e427205b49fb87e689e7d24a9
 SHA512:
-  metadata.gz: d83fb0f51620c2066dd33e9783e42e8730a69648c738099dce74d037ce3208a4b9a9d90de984f9ca3621a8dcd1b79d1cafc5c8acfb9ddf58c1b5ba7a67cae7ef
-  data.tar.gz: 88245931405c031a0c71a54bfa5a12d07930afbc2651ed1020033b8009d1ebf8d80f74b118f1d0548d3041a3b36890362e1021f2a25eb7e46fb9a3b10416343d
+  metadata.gz: 4bff40b1f820583202eecfc003676f46e63533ab9c8dc635a87616b95ce5169a478ed0cad7c2aa692717859320ad0d66a1d8cb898eec091aa955537155091d44
+  data.tar.gz: 725fc52f95deab1a7fb909191b9b1ca14c5f19f1f45316bcd59b5aa014e419cfaee0c7cb865620a79faea9e28bd9b48910b7d4c1aef435fb1806dc689bbf7ba8

data/Changelog.md

@@ -1,3 +1,6 @@
+# 0.7.0
+
+ - Change the output to be a diff-like view rather than verbose prose
 
 # 0.5.2
 

data/Guardfile

@@ -24,7 +24,14 @@
 #  * zeus: 'zeus rspec' (requires the server to be started separately)
 #  * 'just' rspec: 'rspec'
 
-guard :rspec, cmd: "bundle exec rspec" do
+guard :rspec,
+      # cmd: "bin/rspec --no-profile --fail-fast",
+      cmd: "bin/rspec --no-profile",
+      failed_mode: :keep,
+      run_all: { cmd: "bin/rspec --no-profile --tag ~type:feature" }, # skip feature specs on "all"
+      notification: true,
+      all_on_start: false,
+      all_on_pass: false do
   require "guard/rspec/dsl"
   dsl = Guard::RSpec::Dsl.new(self)
 

data/README.md

@@ -2,79 +2,97 @@
 
 [![Gem Version](https://badge.fury.io/rb/rspec-json_api_matchers.svg)](https://badge.fury.io/rb/rspec-json_api_matchers)[![Build Status](https://travis-ci.org/paul/rspec-json_api_matchers.svg?branch=master)](https://travis-ci.org/paul/rspec-json_api_matchers)
 
-This gem provides a set of matchers that make testing JSON documents (actually
-the hashes parsed from them) simpler and more elegant.
+This gem provides a set of matchers that make testing JSON documents (actually the hashes parsed from them) simpler and more elegant.
 
-It provides two primary matchers, `have_attribute` and `resembles`/`resembles_json`.
+## `resemble` Matcher
 
-## `#have_attribute`
+Oftentimes when testing your JSON API responses, you don't care about the actual values matching exactly, just that they "resemble" your expected values. This gem provides a variety of matchers to just get close:
 
-Use this matcher when you want to examine a single attribute, and optionally
-match against its value.
+### Numbers
 
-### Example Usage
+Anything that's a Ruby `Numeric` will match:
 
 ```ruby
-RSpec.describe "my hash" do
-  include RSpec::ResemblesJsonMatchers
+# These pass
+expect(10).to   resemble 42
+expect(3.14).to resemble 42
+expect(10).to   resemble 42.4
+
+# These fail
+expect("string").to resemble 42
+expect(Time.now).to resemble 42
+```
 
-  subject(:response_document) do
-    {
-      author: "Paul",
-      gems_published: 42,
-      created_at: "2016-01-01T00:00:00Z"
-    }
-  end
+I haven't needed it yet, but I'm open to discussing if more accurate matches would be needed. For example:
 
-  # Test that the key is present, regardless of value (even nil)
-  it { should have_attribute :author }
+ * Does 1_000_000_000 "resemble" 1?
+ * Does a float "resemble" an integer?
 
-  # Test the value by using another matcher
-  it { should have_attribute :author, eq("Paul") }
-  it { should have_attribute :author, match(/Paul/) }
-  it { should have_attribute :gems_published, be > 40 }
-  it { should have_attribute :created_at, iso8601_timestamp }
-end
-```
 
-It will also provide nice descriptions in the rspec doc format, and useful
-failure messages:
+### Dates/Times
 
+Anything that is a Ruby `Date`/`Time`/`DateTime`, or a string that can be parsed by `Time.iso8601` will match:
+
+```ruby
+# These pass
+expect(Time.now).to         resemble "2018-01-01T00:00:00Z"
+expect(Time.now.iso8601).to resemble "2018-01-01T00:00:00Z"
+
+# These fail
+expect("Some string").to resemble "2018-01-01T00:00:00Z"
 ```
-my hash
-  should have attribute :author be present
-  should have attribute :author eq "Paul"
-  should have attribute :author match /Paul/
-  should have attribute :gems_published be > 40
-  should have attribute :created_at match /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/
-```
 
+Open questions:
+
+ * Does `"2018-01-01T00:00:00-0700"` "resemble" `"2018-01-01T00:00:00Z"`? That is, should it ensure the timezone matches?
+ * Do non-ISO8601 datetimes "resemble" ISO8601 ones?
+ * Is there a permissible time range? Does the year 1600 "resemble" 2017? Does `"0000-00-00T00:00:00Z"`? Does `Time.at(0)`?
+
+### Rails routes
+
+If you're using Rails (specifically `ActionDispatch`), we can check that routes resemble each other:
+
+```ruby
+# These pass
+expect("/posts/1").to                    resemble posts_path(post)
+expect("/posts/1000000").to              resemble posts_path(post)
+expect("https://example.com/posts/1").to resemble posts_path(post)
+
+# These fail
+expect("/users/1").to    resemble posts_path(post)
+expect("Some string").to resemble posts_path(post)
 ```
-Failures:
 
-  1) my hash should have attribute :full_name be present
-     Failure/Error: it { should have_attribute :full_name }
-       Expected attribute :full_name to be present
-     # ./spec/examples_spec.rb:24:in `block (2 levels) in <top (required)>'
+### Strings
+
+Any string that didn't match one of the other resembles matchers will match:
+
+```ruby
+# These pass
+expect("Some string").to resemble "some other string"
+expect("").to            resemble "some other string"
+expect("a" * 100_000).to resemble "some other string"
+
+# These fail
+expect(42).to       resemble "42"
+expect(Time.now).to resemble "Time.now
 
-  2) my hash should have attribute :author match /paul/
-     Failure/Error: it { should have_attribute :author, match(/paul/) }
-       Expected value of attribute :author to match /paul/ but it was "Paul"
-     # ./spec/examples_spec.rb:25:in `block (2 levels) in <top (required)>'
 ```
 
-## `#resembles_json`
+Open questions:
+
+ * Should there be some heuristic to decide if a string resembles another? Does length matter?
 
-This matcher builds upon `#have_attribute` to let you test an entire JSON document in a single example, but still provide detailed errors about each attribute.
+## `#resemble_json/match_json`
 
-Additionally, it does "fuzzy" matching on the fields (unless a matcher is explicitly given), because its primary purpose it do have a clear and concise example of the API output for documentation.
+The resembles matchers are nice on their own, but their power shines when used with the `resembles_json` matcher. This allows you to write an example JSON document in your spec, and match it against the output from a request. Any values in the "expected" document that aren't already matchers will be converted to the best `resembles` matcher. You can write plain json documents as the expected, or be explicit by specifying matchers.
 
-See the examples folder for more.
 
 ### Example Usage
 
 ```ruby
 RSpec.describe "a basic json document" do
+  # This would probably actually come from something like `JSON.parse(response.body)`
   let(:document) do
     {
       "@id": "/posts/2016/test1",
@@ -89,19 +107,19 @@ RSpec.describe "a basic json document" do
   specify do
     expect(document).to resemble_json(
       {
-        "@id": "/posts/:year/:title",
-        "@type": eq("Post"),
-        "title": "Hello World!",
-        "body": "lorem ipsum",
-        "created_at": "2016-03-01T00:03:42",
-        "published_at": "2016-03-10T15:35:00"
+        "@id": post_path(post),                 # resembles route
+        "@type": eq("Post"),                    # using an explicit matcher to match exactly
+        "title": match(/^Hello/),               # another explicit matcher
+        "body": "lorem ipsum",                  # resembles string
+        "created_at": "2016-03-01T00:03:42",    # resembles time
+        "published_at": post.published_at       # Also resembles time
       }
     )
   end
 end
 ```
 
-Again, it provides good descriptions:
+It provides good descriptions if you run `rspec` with `--format=documentation`:
 
 ```
   a basic json document
@@ -116,21 +134,18 @@ Again, it provides good descriptions:
       }
 ```
 
-And useful failure messages:
+It also provides a failure message as a diff of the JSON object:
 
 ```
-Failures:
-
-  1) The resembles json matcher a basic json document with several attributes that failed to match should resemble json
+  1) The resembles json matcher a basic json document with several attributes that failed to match should have json that looks like
   {
-    "@id": /posts/:year/:title,
+    "@id": "/posts/:year/:title",
     "@type": "PostCollection",
     "title": 42.0,
-    "body": lorem ipsum,
+    "body": "lorem ipsum",
     "created_at": "2016-03-01T00:03:42",
     "published_at": "2016-03-10T15:35:00"
   }
-
      Failure/Error:
        expect(document).to resemble_json(
          {
@@ -143,65 +158,20 @@ Failures:
          }
        )
 
-       failed because
-         attribute "@type":
-           expected: "PostCollection"
-                got: "Post"
-         attribute "title":
-           "Hello World!" does not resemble a number
+       {
+         "@id": "/posts/:year/:title",
+       - "@type": eq "PostCollection",
+       + "@type": "Post",
+       - "title": 42.0,
+       + "title": "Hello World!",
+         "body": "lorem ipsum",
+         "created_at": "2016-03-01T00:03:42",
+         "published_at": "2016-03-10T15:35:00"
+       }
      # ./examples/example_spec.rb:40:in `block (4 levels) in <top (required)>'
-
-  2) The resembles json matcher a basic json document when the matcher is missing a field that is present in the document should resemble json
-  {
-    "@id": /posts/:year/:title,
-    "@type": "Post",
-    "body": lorem ipsum,
-    "created_at": "2016-03-01T00:03:42",
-    "published_at": "2016-03-10T15:35:00"
-  }
-
-     Failure/Error:
-       expect(document).to resemble_json(
-         {
-           "@id": "/posts/:year/:title",
-           "@type": eq("Post"),
-           "body": "lorem ipsum",
-           "created_at": "2016-03-01T00:03:42",
-           "published_at": "2016-03-10T15:35:00"
-         }
-       )
-
-       failed because
-         attribute "title":
-           is present, but no matcher provided to match it
-     # ./examples/example_spec.rb:55:in `block (4 levels) in <top (required)>'
-
-  3) The resembles json matcher a basic json document when the document is missing a field that is present in the matcher should resemble json
-  {
-    "@id": /posts/:year/:title,
-    "@type": "Post",
-    "body": lorem ipsum,
-    "created_at": "2016-03-01T00:03:42",
-    "published_at": "2016-03-10T15:35:00"
-  }
-
-     Failure/Error:
-       expect(document).to resemble_json(
-         {
-           "@id": "/posts/:year/:title",
-           "@type": eq("Post"),
-           "body": "lorem ipsum",
-           "created_at": "2016-03-01T00:03:42",
-           "published_at": "2016-03-10T15:35:00"
-         }
-       )
-
-       failed because
-         attribute "title":
-           is present, but no matcher provided to match it
-     # ./examples/example_spec.rb:69:in `block (4 levels) in <top (required)>'
 ```
 
+It can also handle nested JSON documents and Arrays, showing the proper diffs. See the `./examples` directory, but it works pretty much how you'd expect.
 
 # Installation
 

data/bin/rspec

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+load(bundle_binstub) if File.file?(bundle_binstub)
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/examples/example_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe "The resembles json matcher" do
   include RSpec::ResemblesJsonMatchers
 
   before :all do
-    puts <<-WARNING.strip_heredoc
+    puts <<~WARNING
       NOTE: some of these are expected to fail, they are meant to demonstrate
       the output generated by failing specs
     WARNING
@@ -117,7 +117,65 @@ RSpec.describe "The resembles json matcher" do
         }
       )
     end
+  end
 
+  describe "empty nested documents" do
+    let(:document) do
+      {
+        "@id": "/posts/2016/test1",
+        "@type": "Post",
+        "title": "Hello World!",
+        "body": "lorem ipsum",
+        "created_at": "2016-03-01T00:03:42",
+        "published_at": "2016-03-10T15:35:00"
+      }
+    end
+
+    specify do
+      expect(document).to resemble_json(
+        {
+          "@id": "/posts/:year/:title",
+          "@type": eq("Post"),
+          "title": "Hello World!",
+          "body": "lorem ipsum",
+          "author": {
+            "@id": "/authors/:id",
+            "name": eq("Paul")
+          },
+          "created_at": "2016-03-01T00:03:42",
+          "published_at": "2016-03-10T15:35:00"
+        }
+      )
+    end
+  end
 
+  describe "empty nested array documents" do
+    let(:document) do
+      {
+        "@id": "/posts",
+        "@type": "PostCollection",
+        "nextPage": "/posts?page=2"
+      }
+    end
+
+    specify do
+      expect(document).to resemble_json(
+        {
+          "@id": "/posts",
+          "@type": eq("PostCollection"),
+          "nextPage": "/posts?page=2",
+          "members": [
+            {
+              "@id": "/posts/:year/:title",
+              "@type": eq("Post"),
+              "title": "Hello World!",
+              "body": "lorem ipsum",
+              "created_at": "2016-03-01T00:03:42",
+              "published_at": "2016-03-10T15:35:00"
+            }
+          ]
+        }
+      )
+    end
   end
 end

data/lib/rspec/resembles_json_matchers/attribute_differ.rb

@@ -0,0 +1,150 @@
+require "active_support/inflector"
+
+module RSpec::ResemblesJsonMatchers
+  class AttributeDiffer
+    def initialize(matcher)
+      @matcher = matcher
+    end
+
+    def to_s
+      @buffer = StringIO.new
+      @buffer.puts NEUTRAL_COLOR + "Diff:"
+      render(@matcher)
+      @buffer.string
+    end
+
+    private
+
+    def render(matcher, **opts)
+      class_name = ActiveSupport::Inflector.demodulize(matcher.class.to_s)
+      method_name = :"render_#{class_name}"
+      send method_name, matcher, **opts
+    end
+
+    def render_JsonMatcher(matcher, prefix: "", starts_on_newline: false, **opts)
+      @buffer.print prefix if starts_on_newline
+      @buffer.print NORMAL_COLOR unless prefix.include?("-")
+      @buffer.puts "{"
+      matcher.expected_matchers.each do |key, attr_matcher|
+        last = (matcher.expected_matchers.keys.last == key)
+        render(attr_matcher, prefix: prefix, last: last, **opts)
+      end
+      if matcher.actual.nil?
+        @buffer.print REMOVED_COLOR
+        if prefix.include? "-"
+          @buffer.print prefix + "}"
+        else
+          @buffer.print prefix + "- }"
+        end
+      else
+        @buffer.print NORMAL_COLOR unless prefix.include?("-")
+        @buffer.print prefix + "}"
+      end
+    end
+
+    def render_AttributeMatcher(matcher, prefix: "", last: false)
+      if matcher.matched?
+        @buffer.print NORMAL_COLOR
+        @buffer.print prefix + "  " + "#{matcher.attribute_name.to_json}: "
+        render(matcher.value_matcher, prefix: prefix + "  ")
+        @buffer.print(",") unless last
+        @buffer.puts
+      else
+        if nested_matcher?(matcher.value_matcher)
+          if matcher.missing_attribute?
+            prefix = prefix + "- "
+            @buffer.print REMOVED_COLOR
+            @buffer.print prefix + "#{matcher.attribute_name.to_json}: "
+            render(matcher.value_matcher, prefix: prefix)
+            @buffer.print(",") unless last
+            @buffer.puts
+          else
+            @buffer.print NORMAL_COLOR
+            @buffer.print prefix + "  " + "#{matcher.attribute_name.to_json}: "
+            render(matcher.value_matcher, prefix: prefix + "  ")
+            @buffer.print(",") unless last
+            @buffer.puts
+          end
+        else
+          @buffer.print REMOVED_COLOR
+          @buffer.print prefix
+          if prefix.include? "-"
+            @buffer.print "  "
+          else
+            @buffer.print "- "
+          end
+          @buffer.print "#{matcher.attribute_name.to_json}: "
+          render(matcher.value_matcher, prefix: prefix + "  ")
+          @buffer.print NORMAL_COLOR
+          @buffer.print(",") unless last
+          @buffer.puts
+          unless matcher.missing_attribute?
+            @buffer.print ADDED_COLOR
+            @buffer.print prefix + "+ #{matcher.attribute_name.to_json}: "
+            render(matcher.actual_value, prefix: prefix + "  ")
+            @buffer.print NORMAL_COLOR
+            @buffer.print(",") unless last
+            @buffer.puts
+          end
+        end
+      end
+    end
+
+    def render_ResemblesAnyOfMatcher(matcher, prefix: "", **opts)
+      @buffer.puts "["
+      if matcher.actual.nil? || matcher.actual.empty?
+        example_matcher = matcher.expected.first
+        render example_matcher, prefix: prefix + "  ", starts_on_newline: true
+        @buffer.puts
+      else
+        matcher.attempted_matchers.each do |attempted_matcher|
+          last = (matcher.attempted_matchers.last == attempted_matcher)
+          render attempted_matcher, prefix: prefix + "  ", starts_on_newline: true
+          @buffer.print(",") unless last
+          @buffer.puts
+        end
+      end
+      @buffer.print prefix + "]"
+    end
+
+    def render_ResemblesStringMatcher(matcher, **opts)
+      @buffer.print matcher.expected.to_json
+    end
+
+    def render_ResemblesDateMatcher(matcher, **opts)
+      @buffer.print matcher.expected.to_json
+    end
+
+    def render_ResemblesNumericMatcher(matcher, **opts)
+      @buffer.print matcher.expected.to_json
+    end
+
+    def render_ResemblesClassMatcher(matcher, **opts)
+      @buffer.print matcher.expected.inspect
+    end
+
+    def method_missing(method_name, *args, &block)
+      if method_name.to_s.start_with?("render_")
+        raise NoMethodError, method_name if method_name.to_s.end_with?("Matcher")
+        @buffer.print RSpec::Support::ObjectFormatter.format(args.first)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s.start_with?("render_")
+    end
+
+    def nested_matcher?(matcher)
+      matcher.is_a?(JsonMatcher) || matcher.is_a?(ResemblesAnyOfMatcher)
+    end
+
+    NORMAL_COLOR  = "\e[0m".freeze
+    REMOVED_COLOR = "\e[31m".freeze # Red
+    ADDED_COLOR   = "\e[32m".freeze # Green
+    NEUTRAL_COLOR = "\e[34m".freeze # Blue
+
+  end
+end
+

data/lib/rspec/resembles_json_matchers/attribute_matcher.rb

@@ -18,30 +18,39 @@ module RSpec::ResemblesJsonMatchers
     def matches?(document)
       @document = document.with_indifferent_access
 
-      @document.key?(attribute_name) &&
-        expected.matches?(@document.fetch(attribute_name, nil))
+      @matched = !missing_attribute? && expected.matches?(actual_value)
     end
 
     def failure_message
-      if expected === NullMatcher
-        msgs = ["Expected attribute",
-                attribute_name.inspect,
-                "to be present"]
+      if missing_attribute?
+        %{Expected document to have attribute #{attribute_name.inspect}}
       else
-        msgs = ["Expected value of attribute",
-                attribute_name.inspect,
-                "to",
-                expected.description,
-                "but it was",
-                document[attribute_name].inspect]
+        %{Expected attribute #{attribute_name.inspect} to #{value_matcher.description}, but it was #{actual_value.inspect}}
       end
-      sentencize(*msgs)
     end
 
-    def failure_message_when_negated
-      sentencize "Expected attribute #{attribute_name.inspect}",
-                 expected.description,
-                 "to be absent"
+    def matched?
+      @matched
+    end
+
+    def value_matcher
+      @expected
+    end
+
+    def expected_value
+      value_matcher.expected
+    end
+
+    def actual_value
+      document.fetch(attribute_name, nil)
+    end
+
+    def missing_attribute?
+      !has_attribute?
+    end
+
+    def has_attribute?
+      document && document.key?(attribute_name)
     end
 
     NullMatcher = Class.new do
@@ -63,23 +72,5 @@ module RSpec::ResemblesJsonMatchers
       end
     end.new
 
-    def matcherize(expected)
-      if matcher? expected
-        expected
-
-      elsif expected.respond_to? :===
-        RSpec::Matchers::Builtin::Match.new(expected)
-
-      else
-        RSpec::Matchers::Builtin::Eq.new(expected)
-      end
-    end
-
-    def matcher?(obj)
-      obj.respond_to(:matches?) && (obj.respond_to?(:failure_message) ||
-                                     obj.respond_to?(:failure_message_for_should))
-    end
-
   end
-
 end

data/lib/rspec/resembles_json_matchers/json_matcher.rb

@@ -1,58 +1,50 @@
-require "active_support/core_ext/hash/keys"     # stringify_keys
-
+require "active_support/core_ext/hash/keys" # stringify_keys
 require "json"
 
+require "rspec/resembles_json_matchers/attribute_differ"
+
 module RSpec::ResemblesJsonMatchers
   class JsonMatcher
     include RSpec::Matchers::Composable
-    include RSpec::ResemblesJsonMatchers::Helpers
+    include Helpers
+
+    def self.can_match?(hash)
+      hash.is_a? Hash
+    end
+
+    attr_reader :expected, :actual
 
     def initialize(expected_json)
-      @expected_json = expected_json.stringify_keys
-      @failed_matchers = {}
+      @expected = expected_json.deep_stringify_keys
     end
 
     def matches?(actual_json)
-      @actual_json = actual_json
-      expected_matchers.each do |expected_key, value_matcher|
-        attr_matcher = AttributeMatcher.new(expected_key, value_matcher)
-        match = attr_matcher.matches?(@actual_json)
-        @failed_matchers[expected_key] = attr_matcher unless match
+      @actual = actual_json.deep_stringify_keys
+      all_passed = true
+      expected_matchers.each do |key, attr_matcher|
+        result = attr_matcher.matches?(actual)
+        all_passed &&= result
       end
-      @failed_matchers.size == 0
+      all_passed
     end
 
     def description
       # TODO Figure out how to discover the right indent level
-      "have json that looks like\n#{expected_formatted.indent(6)}"
+      "have json that looks like\n#{expected_formatted.indent(2)}"
     end
 
     def failure_message
-      msgs = [ "Expected:",
-                pretty_actual.indent(2),
-                "To match:",
-                expected_formatted.indent(2),
-                "Failures:",
-                pretty_errors.indent(2) ]
-      msgs.join("\n")
+      AttributeDiffer.new(self).to_s
     end
 
-    def pretty_json(obj)
-      JSON.pretty_generate(obj)
-    end
-
-    def expected_formatted
-      pretty_json(@expected_json)
-    end
-
-    def pretty_actual
-      pretty_json(@actual_json)
+    def to_json
+      failure_message
     end
 
     def expected_matchers
       @expected_matchers ||= {}.tap do |hsh|
-        @expected_json.each do |k,v|
-          hsh[k] = v.respond_to?(:description) ? v : RSpec::Matchers::BuiltIn::Eq.new(v)
+        expected.each do |k,v|
+          hsh[k.to_s] = AttributeMatcher.new(k, matcherize(v))
         end
       end
     end
@@ -60,23 +52,34 @@ module RSpec::ResemblesJsonMatchers
     def expected_formatted
       out = "{\n"
       out << expected_matchers.map do |k,v|
-        case v
-        when RSpec::Matchers::BuiltIn::Eq
-          %{"#{k}": #{v.expected_formatted}}.indent(2)
-        else
-          %{"#{k}": #{v.description}}.indent(2)
-        end
+        %{"#{k}": #{RSpec::Support::ObjectFormatter.format(v.expected_value)}}.indent(2)
       end.join(",\n")
       out << "\n}"
     end
 
-    def pretty_errors
-      out = "{\n"
-      out << @failed_matchers.map do |k,v|
-        %{"#{k}": #{v.failure_message}}.indent(2)
-      end.join(",\n")
-      out << "\n}"
+    def color_lines(text)
+      text.split("\n").map do |line|
+        case line.chr[0]
+          when "-" then red line
+          when "+" then green line
+        end
+      end.compact
+    end
+
+    def color(text, color_code)
+      "\e[#{color_code}m#{text}\e[0m"
     end
 
+    def red(text)
+      color(text, 31)
+    end
+
+    def green(text)
+      color(text, 32)
+    end
+
+    def normal(text)
+      color(text, 0)
+    end
   end
 end

data/lib/rspec/resembles_json_matchers/resembles_any_of_matcher.rb

@@ -8,13 +8,16 @@ module RSpec::ResemblesJsonMatchers
       array.is_a? Array
     end
 
+    attr_reader :expected, :actual
+
     def initialize(expected)
-      @expected = expected
+      @expected = expected.map { |e| matcherize(e) }
     end
 
     def matches?(actual)
-      Array.wrap(actual).flatten.all? do |a|
-        expected_matchers.any? { |m| m.matches? a }
+      @actual = Array.wrap(actual)
+      @actual.all? do |a|
+        expected_matchers.any? { |m| attempted_matchers << m; m.matches? a }
       end
     end
 
@@ -27,17 +30,15 @@ module RSpec::ResemblesJsonMatchers
     end
 
     def failure_message
-      sentencize ["Expected every item to match one of:\n",
-                  expected_formatted,
-                  "The item at",
-                  # failed_item_indexes,
-                  "did not because:\n",
-                  failure_messages]
 
     end
 
     def expected_matchers
-      @expected.map { |e| matcherize(e) }
+      @expected
+    end
+
+    def attempted_matchers
+      @attempted_matchers ||= []
     end
 
     def expected_formatted
@@ -52,10 +53,5 @@ module RSpec::ResemblesJsonMatchers
         end.join("\n")
       end << "\n"
     end
-
-    def failure_messages
-    end
-
   end
-
 end

data/lib/rspec/resembles_json_matchers/resembles_class_matcher.rb

@@ -5,6 +5,8 @@ module RSpec::ResemblesJsonMatchers
       klass.is_a? Class
     end
 
+    attr_reader :expected
+
     def initialize(expected)
       @expected = expected
     end

data/lib/rspec/resembles_json_matchers/resembles_date_matcher.rb

@@ -20,8 +20,11 @@ module RSpec::ResemblesJsonMatchers
       end
     end
 
+    attr_reader :expected
+
     def initialize(expected)
       @expected = expected
+      # @expected = expected.is_a?(String) ? Time.parse(expected) : expected
     end
 
     def description
@@ -33,10 +36,6 @@ module RSpec::ResemblesJsonMatchers
       self.class.can_match?(actual)
     end
 
-    def expected_formatted
-      @expected.inspect.to_s
-    end
-
     def failure_message
       "#{@actual.inspect} does not resemble a Date or Timestamp"
     end

data/lib/rspec/resembles_json_matchers/resembles_hash_matcher.rb

@@ -20,7 +20,7 @@ module RSpec::ResemblesJsonMatchers
       expected_matchers.each do |expected_key, value_matcher|
         @matched_keys << expected_key
 
-        attr_matcher = RSpec::ResemblesJsonMatchers::AttributeMatcher.new(expected_key, value_matcher)
+        attr_matcher = AttributeMatcher.new(expected_key, value_matcher)
         match = attr_matcher.matches?(actual)
 
         if match
@@ -42,11 +42,11 @@ module RSpec::ResemblesJsonMatchers
     end
 
     def failure_message
-      "failed because\n" +
-        pretty_failed_matches.indent(2) +
-        pretty_unmatched_keys.indent(2) +
-        pretty_unmatched_matchers.indent(2) +
-        "\n"
+      "failed because\n" + [
+        pretty_failed_matches.indent(2),
+        pretty_unmatched_keys.indent(2),
+        pretty_unmatched_matchers.indent(2)
+      ].join("\n") + "\n"
     end
 
     protected

data/lib/rspec/resembles_json_matchers/resembles_numeric_matcher.rb

@@ -1,12 +1,12 @@
 
 module RSpec::ResemblesJsonMatchers
   class ResemblesNumericMatcher
-    NUMBER_REGEX = /\A\d+\Z/.freeze
     def self.can_match?(number)
-      number.is_a?(Numeric) ||
-        number =~ NUMBER_REGEX
+      number.is_a?(Numeric)
     end
 
+    attr_reader :expected
+
     def initialize(expected)
       @expected = expected
     end
@@ -25,6 +25,10 @@ module RSpec::ResemblesJsonMatchers
       @expected
     end
 
+    def to_json
+      @expected
+    end
+
     def failure_message
       "#{@actual.inspect} does not resemble a number"
     end

data/lib/rspec/resembles_json_matchers/resembles_string_matcher.rb

@@ -5,6 +5,8 @@ module RSpec::ResemblesJsonMatchers
       string.is_a? String
     end
 
+    attr_reader :expected
+
     def initialize(expected)
       @expected = expected
     end
@@ -17,9 +19,5 @@ module RSpec::ResemblesJsonMatchers
     def matches?(actual)
       self.class.can_match?(actual)
     end
-
-    def expected_formatted
-      @expected
-    end
   end
 end

data/lib/rspec/resembles_json_matchers/version.rb

@@ -1,5 +1,5 @@
 module Rspec
   module ResemblesJsonMatchers
-    VERSION = "0.6.0"
+    VERSION = "0.7.0"
   end
 end

data/lib/rspec/resembles_json_matchers.rb

@@ -4,13 +4,9 @@ require "rspec/resembles_json_matchers/string_indent"
 module RSpec
   module ResemblesJsonMatchers
     autoload :AttributeMatcher, "rspec/resembles_json_matchers/attribute_matcher"
-    # autoload :ResemblesMatcher, "rspec/resembles_json_matchers/resembles_matcher"
     autoload :JsonMatcher,      "rspec/resembles_json_matchers/json_matcher"
     autoload :Helpers,          "rspec/resembles_json_matchers/helpers"
-    # autoload :Matcherizer,      "rspec/resembles_json_matchers/matcherizer"
 
-    autoload :ResemblesHashMatcher,    "rspec/resembles_json_matchers/resembles_hash_matcher"
-    autoload :ResemblesArrayMatcher,   "rspec/resembles_json_matchers/resembles_array_matcher"
     autoload :ResemblesAnyOfMatcher,   "rspec/resembles_json_matchers/resembles_any_of_matcher"
     autoload :ResemblesRouteMatcher,   "rspec/resembles_json_matchers/resembles_route_matcher"
     autoload :ResemblesDateMatcher,    "rspec/resembles_json_matchers/resembles_date_matcher"
@@ -27,22 +23,17 @@ module RSpec
     def match_json(*a)
       JsonMatcher.new(*a)
     end
-
-    def have_attribute(*a)
-      AttributeMatcher.new(*a)
-    end
+    alias resemble_json match_json
 
     def resembles(*a)
       RSpec::ResemblesJsonMatchers.resembles_matcher_for(*a).new(*a)
     end
     alias resemble resembles
-    alias resemble_json resembles
 
     def self.resembles_matcher_candidates
       # Order matters
       @candidates ||= [
-        ResemblesHashMatcher,
-        #ResemblesArrayMatcher,
+        JsonMatcher,
         ResemblesAnyOfMatcher,
         ResemblesRouteMatcher,
         ResemblesDateMatcher,
@@ -55,7 +46,7 @@ module RSpec
     end
 
     def self.resembles_matcher_for(expected, **a)
-      resembles_matcher_candidates.detect { |candidate| candidate.can_match?(expected) } || raise("No matcher available for #{expected.inspect}")
+      resembles_matcher_candidates.detect { |candidate| candidate.can_match?(expected) } || RSpec::Matchers::BuiltIn::Eq
     end
 
   end

data/rspec-resembles_json_matchers.gemspec

@@ -31,9 +31,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "appraisal"
   spec.add_development_dependency "guard"
   spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "pry-state"
   spec.add_development_dependency "awesome_print"
 
   spec.add_runtime_dependency "rspec", ">= 2.0", "< 4.0.0.a"
   spec.add_runtime_dependency "rspec-expectations", ">= 2.0", "< 4.0.0.a"
+  spec.add_runtime_dependency "rspec-support", ">= 2.0", "< 4.0.0.a"
   spec.add_runtime_dependency "activesupport", ">= 3.0" # For core extensions
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-resembles_json_matchers
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Paul Sadauskas
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-20 00:00:00.000000000 Z
+date: 2017-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-state
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: awesome_print
   requirement: !ruby/object:Gem::Requirement
@@ -148,6 +176,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: 4.0.0.a
+- !ruby/object:Gem::Dependency
+  name: rspec-support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 4.0.0.a
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 4.0.0.a
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -178,6 +226,7 @@ files:
 - Guardfile
 - README.md
 - Rakefile
+- bin/rspec
 - examples/example_spec.rb
 - gemfiles/rails_32.gemfile
 - gemfiles/rails_32.gemfile.lock
@@ -188,6 +237,7 @@ files:
 - gemfiles/rails_5.gemfile
 - gemfiles/rails_5.gemfile.lock
 - lib/rspec/resembles_json_matchers.rb
+- lib/rspec/resembles_json_matchers/attribute_differ.rb
 - lib/rspec/resembles_json_matchers/attribute_matcher.rb
 - lib/rspec/resembles_json_matchers/helpers.rb
 - lib/rspec/resembles_json_matchers/json_matcher.rb
@@ -225,7 +275,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Helpful matchers for comparing JSON documents.