eq_json 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9ec463196fe5607b1e9b24b069a789c237c4dd28
+  data.tar.gz: aa249d10540740c92146fc97766617812409cefa
+SHA512:
+  metadata.gz: 2a431e39d5628ab69001a5fde73f84713227395baac64f038cf7d29ed443c758ae492397637e053836bbf4564ba810408ae31ef0b2e76eda70ffe2762a5883e0
+  data.tar.gz: 17f55e32ef6021a364cae492e213fd50b733114234fa74067891dfcb4888ac2672fde88b82c917f157e3c173d37c834e737de0366f73ab9a27e1130f19360f71

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea
+*.iml
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.4

data/CHANGELOG

@@ -0,0 +1,10 @@
+Version 0.0.1 eq_wo_order is released
+Version 0.1.0 Support for arrays of arrays and more complicated structures.
+Version 0.2.0 Support for arrays of hashes of arrays etc - more complicated nesting. Initial support for arrays of disparate types.
+Version 0.2.1 Small description update
+Version 0.2.2 Include CHANGELOG
+Version 0.2.3 Update description with github link
+Version 0.2.4 Ruby-ism refactors for terseness
+Version 0.3.0 Support for nil-case
+Version 0.3.1 Refactor large amounts of code to use Enumerable::any/all, thanks to @jacobsimeon
+Version 0.4.0 Added diffable macro for better output (shows diff of expectation and actual)

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Jean de Klerk
+
+MIT License
+
+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,73 @@
+# EqJson
+
+<!-- [![Build Status](https://travis-ci.org/jadekler/eq_wo_order.svg?branch=master)](https://travis-ci.org/jadekler/eq_wo_order) -->
+
+RSpec equality matcher that JSON.  Outputs meaningful failure messages.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'eq_json'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install eq_json
+```
+
+## Usage
+
+```ruby
+require 'eq_json'
+
+actual = {
+  name: 'Harry Potter and the Sorcerer\'s Stone',
+  publisherInfo: {
+    publishDate: {
+      year: 2015,
+      month: 3,
+      day: 23
+    },
+    name: "ACME Publisher Inc."
+  },
+  author: 'J.K. Rowling'
+}
+
+expected = {
+  name: 'Harry Potter and the Sorcerer\'s Stone',
+  author: 'J.K. Rowling',
+  publisherInfo: {
+    name: "ACME Publisher Inc.",
+    publishDate: {
+      month: 3,
+      day: 23,
+      year: 2015
+    }
+  }
+}
+
+expect(expected).to eq_json(actual)
+```
+# More Documentation
+[Keynote Slides](https://github.com/davidmrhodes/eq_json/blob/master/doc/eqJsonPresentation.key)
+
+If you don't have keynote here is
+[Quicktime Slide show](https://github.com/davidmrhodes/eq_json/blob/master/doc/eqJsonPresentation.m4v)
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/eq_json/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+
+task :default do
+  puts system('bundle exec rspec')
+end

data/TODO.txt

@@ -0,0 +1,31 @@
+1) Implement array equals
+    a) make sure to test that arrays with same objects but different number of
+    same objects is not equal.  Must test with same number of total objects in
+    array
+
+2) Document that did not use matcher DSL.  Easier to test if just used class.
+
+3)  Look to see on diff what should get actual is green or red?
+    Answer:  expected is - in red
+
+4) If object is a string and is multi line use differ in failure_message
+
+5) test for json object combinations of (do for actual also)
+       first key in map not in expected
+       middle key in map not in expected
+       last key in map not in expected
+
+6) Do I need to check expected and actual are valid josn?
+
+
+7) Add comparable function with an selection criteria for and id to compare arrays
+
+8) If objects are large write them to a files in temp
+Could be done via configuration to find if configuration exists:
+
+if RSpec.configuration.methods.include? :json_debug_config
+   puts "json_debug_config #{RSpec.configuration.json_debug_config}"
+end
+
+Then put this in spec_helper:
+c.json_debug_config=true

data/eq_json.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name        = 'eq_json'
+  s.version     = '1.0.2'
+  s.date        = '2016-02-29'
+  s.summary     = 'RSpec equality matcher that to compare JSON'
+  s.description = 'RSpec equality matcher that deeply compares JSON. Examples at github.com/davidmrhodes/eq_json'
+   s.authors     = ['David M. Rhodes']
+  s.email       = 'barnaby71@gmail.com'
+  s.homepage    = 'http://rubygems.org/gems/eq_json'
+  s.license     = 'MIT'
+
+  s.files       = `git ls-files -z`.split("\x0").find_all{|file| file !~ /doc\//}
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'bundler', '~> 1.7'
+  s.add_development_dependency 'rake', '~> 10.0'
+end

data/lib/colorizer.rb

@@ -0,0 +1,23 @@
+class EqJsonColorizer
+  def initialize
+  end
+
+  def green(text)
+    return colorize(text, 32);
+  end
+
+  def red(text)
+    colorize(text, 31)
+  end
+
+  def blue(text)
+    colorize(text, 34)
+  end
+
+  private
+
+  def colorize(text, colorCode)
+    "\e[#{colorCode}m#{text}\e[0m"
+  end
+
+end

data/lib/eq_json.rb

@@ -0,0 +1,142 @@
+require 'pp'
+require 'message_generator'
+require 'eq_json_array'
+
+class EqualWithOutOrderJson
+
+  attr_accessor :actual, :expected, :jsonPath, :jsonPathRoot, :currentActualObj,
+                :currentExpectedObj, :currentJsonKey
+
+  def initialize(expected)
+    @expected = expected
+    @jsonPathRoot = "$."
+    @jsonPath = @jsonPathRoot
+    @messageGenerator = EqJsonMessageGenerator.new(self)
+  end
+
+  def matches?(actual)
+    @actual = actual
+
+    matchesObject?(@expected, @actual)
+  end
+
+  def failure_message
+    return @failureMessage
+  end
+
+  def failure_message_when_negated
+    "Expeced failure_message_when_nagated"
+  end
+
+  def description
+    "Excpect {@expected}"
+  end
+
+  private
+
+  def matchesObject?(expectedObj, actualObj)
+
+    @currentActualObj = actualObj
+    @currentExpectedObj = expectedObj
+
+    case actualObj
+      when Array
+        return arrays_match?(expectedObj, actualObj)
+      when Hash
+        return hashes_match?(expectedObj, actualObj)
+      else
+        unless expectedObj == actualObj
+          @failureMessage = @messageGenerator.generateDifferentValueMessage();
+          return false;
+        end
+    end
+
+    return true;
+
+  end
+
+  def arrays_match?(expectedObj, actualArray)
+    unless actualArray.class == expectedObj.class
+      @failureMessage = @messageGenerator.generateTypeMissMatchFailureMessage()
+      return false;
+    end
+
+    unless actualArray.length == expectedObj.length
+      @failureMessage = @messageGenerator.generateDifferentSizeArrayMessage();
+      return false;
+    end
+
+    arrayUtil = EqualJsonArray.new
+
+    expectedObj.each do |expectedItem|
+
+      expectedCount = expectedObj.count do |item|
+        arrayUtil.itemEqual?(expectedItem, item)
+      end
+
+      actualCount = actualArray.count do |candidate|
+        arrayUtil.itemEqual?(expectedItem, candidate)
+      end
+
+      if expectedCount != actualCount
+        @failureMessage = @messageGenerator.generateExpectedItemNotFoundInArray(expectedItem, expectedCount, actualCount)
+        return false
+      end
+
+    end
+
+    return true
+  end
+
+  def hashes_match?(expectedObj, actualHash)
+    unless actualHash.class == expectedObj.class
+      @failureMessage = @messageGenerator.generateTypeMissMatchFailureMessage()
+      return false;
+    end
+
+    unless actualHash.length == expectedObj.length
+      @failureMessage = @messageGenerator.generateDifferentKeyMessage();
+      return false;
+    end
+
+    expectedObj.each do |expectedKey, expectedValue|
+      @currentJsonKey = expectedKey
+      actualValue = actualHash[expectedKey]
+      if actualValue.nil?
+        @currentActualObj = actualHash
+        @currentExpectedObj = expectedObj
+        @failureMessage = @messageGenerator.generateDifferentKeyMessage()
+        return false
+      end
+
+      addKeyToPath(expectedKey)
+      match = matchesObject?(expectedValue, actualHash[expectedKey])
+      removeKeyFromPath(expectedKey)
+      if match == false
+        return false;
+      end
+    end
+
+    return true
+
+  end
+
+  def addKeyToPath(jsonKey)
+    if @jsonPath[@jsonPath.length-1] != "."
+      @jsonPath << "."
+    end
+    @jsonPath << "#{jsonKey}"
+  end
+
+  def removeKeyFromPath(jsonKey)
+    @jsonPath = @jsonPath[0, @jsonPath.length - "#{jsonKey}".length - 1]
+    if @jsonPath == "$"
+      @jsonPath << "."
+    end
+  end
+
+end
+
+def eq_json(*args)
+  EqualWithOutOrderJson.new(*args)
+end

data/lib/eq_json_array.rb

@@ -0,0 +1,33 @@
+class EqualJsonArray
+
+  def itemEqual?(item1, item2)
+    return false unless item1.class == item2.class
+
+    case item1
+      when Array
+        arraysMatch?(item1, item2)
+      when Hash
+        hashesMatch?(item1, item2)
+      else
+        item1 == item2
+    end
+  end
+
+  private
+
+  def arraysMatch?(actual, expected)
+    return false unless actual.length == expected.length
+    expected.all? do |expectedItem|
+      actual.any? do |candidate|
+        itemEqual?(candidate, expectedItem)
+      end
+    end
+  end
+
+  def hashesMatch?(actual, expected)
+    return false unless arraysMatch?(actual.keys, expected.keys)
+    expected.all? do |expectedKey, expectedValue|
+      itemEqual?(actual[expectedKey], expectedValue)
+    end
+  end
+end

data/lib/message_generator.rb

@@ -0,0 +1,172 @@
+require 'colorizer'
+
+class EqJsonMessageGenerator
+
+  def initialize(matcher)
+    @matcher = matcher
+    @colorizer = EqJsonColorizer.new
+  end
+
+  def generateTypeMissMatchFailureMessage()
+
+    if @matcher.currentJsonKey.nil?
+      actualType = getJsonType(@matcher.actual)
+      expectedType = getJsonType(@matcher.expected)
+    else
+      actualType = getJsonType(@matcher.currentActualObj)
+      expectedType = getJsonType(@matcher.currentExpectedObj)
+      currentJsonDiff = "\tExpected: #{@matcher.currentExpectedObj.to_json}\n" +
+          @colorizer.green("\t  Actual: #{@matcher.currentActualObj.to_json}") + "\n"
+    end
+
+    jsonErrorInfo = "JSON path #{@matcher.jsonPath} expected #{expectedType} type but actual is #{actualType}\n"
+    unless currentJsonDiff.nil?
+      jsonErrorInfo << currentJsonDiff
+    end
+
+    return getExpectedActualJson() +"\n" +
+        "Diff:\n" +
+        "#{jsonErrorInfo}"
+  end
+
+  def generateDifferentValueMessage()
+
+    # TODO have item in todo list to use a diff if the value is a String
+    #      with mutiple lines so leaving this diff code even though it is not
+    #      being used
+    differ = RSpec::Support::Differ.new
+
+    differ = RSpec::Support::Differ.new(
+        :object_preparer => lambda {|expected| RSpec::Matchers::Composable.surface_descriptions_in(expected)},
+        :color => RSpec::Matchers.configuration.color?
+    )
+
+    @difference = differ.diff_as_object(@matcher.currentExpectedObj, @matcher.currentActualObj)
+    # End unused code
+
+    return getExpectedActualJson() + "\n" +
+        "Diff:\n" +
+        "JSON path #{@matcher.jsonPath}\n" +
+        "\texpected: \"#{@matcher.currentExpectedObj}\"\n" +
+        @colorizer.green("\t     got: \"#{@matcher.currentActualObj}\"")
+  end
+
+  def generateDifferentKeyMessage()
+    if @matcher.currentActualObj.nil?
+      objectsNotInExpected = getObjectsNotIn(@matcher.actual, @matcher.expected);
+      objectsNotInActual = getObjectsNotIn(@matcher.expected, @matcher.actual);
+    else
+      objectsNotInExpected = getObjectsNotIn(@matcher.currentActualObj, @matcher.currentExpectedObj);
+      objectsNotInActual = getObjectsNotIn(@matcher.currentExpectedObj, @matcher.currentActualObj);
+    end
+
+    jsonErrorInfo = "JSON path #{@matcher.jsonPath}\n"
+
+    unless objectsNotInExpected.empty?
+      jsonErrorInfo << "expected does not contain #{objectsNotInExpected.to_json}\n"
+    end
+
+    unless objectsNotInActual.empty?
+      jsonErrorInfo << @colorizer.green("actual does not contain #{objectsNotInActual.to_json}\n")
+    end
+
+    differ = RSpec::Support::Differ.new
+
+    differ = RSpec::Support::Differ.new(
+        :object_preparer => lambda {|expected| RSpec::Matchers::Composable.surface_descriptions_in(expected)},
+        :color => RSpec::Matchers.configuration.color?
+    )
+
+    if @matcher.currentActualObj.nil?
+      @difference = differ.diff(@matcher.expected, @matcher.actual)
+    else
+      @difference = differ.diff(@matcher.currentExpectedObj, @matcher.currentActualObj)
+    end
+
+    return getExpectedActualJson() + "\n" +
+        "\nDiff:\n" +
+        jsonErrorInfo +
+        @difference
+  end
+
+  def getExpectedActualJson
+    expectedJson=@matcher.expected.to_json;
+    actualJson=@matcher.actual.to_json;
+
+    return "Expected: #{expectedJson}\n" +
+        @colorizer.green("  Actual: #{actualJson}")
+  end
+
+  def getObjectsNotIn(hash1, hash2)
+    missing = {}
+    hash1.each do |hash1_key, hash1_value|
+      unless hash2.has_key?(hash1_key)
+        missing[hash1_key] = hash1_value
+      end
+    end
+    return missing
+  end
+
+  def getJsonType(rubyJsonObject)
+    case rubyJsonObject
+      when Array
+        return "array"
+      when Hash
+        return "object"
+      else
+        return "not json"
+    end
+  end
+
+  def generateDifferentSizeArrayMessage()
+    if @matcher.currentActualObj.nil?
+      expectedLength = @matcher.expected.length
+      actualLength = @matcher.actual.length
+    else
+      expectedLength = @matcher.currentExpectedObj.length
+      actualLength = @matcher.currentActualObj.length
+    end
+
+    jsonErrorInfo = "JSON path #{@matcher.jsonPath}[] expected length #{expectedLength} " +
+        "actual length #{actualLength}\n"
+
+    return getExpectedActualJson() + "\n" +
+        "\nDiff:\n" +
+        jsonErrorInfo
+  end
+
+  def generateExpectedItemNotFoundInArray(expected_item, expected_count, actual_count)
+    # if @matcher.currentActualObj.nil?
+    #    objectsNotInExpected = getObjectsNotInArray(@matcher.actual, @matcher.expected);
+    #    objectsNotInActual = getObjectsNotInArray(@matcher.expected, @matcher.actual);
+    # else
+    #    objectsNotInExpected = getObjectsNotIn(@matcher.currentActualObj, @matcher.currentExpectedObj);
+    #    objectsNotInActual = getObjectsNotIn(@matcher.currentExpectedObj, @matcher.currentActualObj);
+    # end
+
+    if actual_count == 0
+      jsonErrorInfo = "JSON path #{@matcher.jsonPath}[] could not find:\n" +
+          "#{expected_item.to_json}\n" +
+          "in actual\n"
+    else
+      jsonErrorInfo = "JSON path #{@matcher.jsonPath}[] wrong number of:\n" +
+          "#{expected_item.to_json}\n" +
+          "in actual\n" +
+          "expected: #{expected_count}\n" +
+          @colorizer.green("     got: #{actual_count}") + "\n"
+    end
+
+    # unless objectsNotInExpected.empty?
+    #   jsonErrorInfo << "expected does not contain #{objectsNotInExpected.to_json}\n"
+    # end
+    #
+    # unless objectsNotInActual.empty?
+    #   jsonErrorInfo << @colorizer.green("actual does not contain #{objectsNotInActual.to_json}\n")
+    # end
+
+    return getExpectedActualJson() + "\n" +
+        "\nDiff:\n" +
+        jsonErrorInfo
+  end
+
+end

data/lib/version/version.rb

@@ -0,0 +1,3 @@
+module EqWoOrder
+  VERSION = '0.0.1'
+end

data/spec/features/colorizer_spec.rb

@@ -0,0 +1,19 @@
+require 'colorizer'
+
+describe 'test color' do
+
+  it 'expected red text' do
+    colorizer = EqJsonColorizer.new()
+    expect("\e[31mtest42\e[0m").to eq(colorizer.red("test42"))
+  end
+
+  it 'expected green text' do
+    colorizer = EqJsonColorizer.new()
+    expect("\e[32mtest42\e[0m").to eq(colorizer.green("test42"))
+  end
+
+  it 'expected blue text' do
+    colorizer = EqJsonColorizer.new()
+    expect("\e[34mtest42\e[0m").to eq(colorizer.blue("test42"))
+  end
+end