mismatch-inspectable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 671248717fed7d33e53f9e167f8e58d7344189fc8f2a77ab2b4fbcad603db188
+  data.tar.gz: 3c45218dd7adbbde45baddfa827ee71de4f2781d1e50aa44ce465567eca98f92
+SHA512:
+  metadata.gz: 365ef02e25f9e3d697d887ddab05c9fb14aeedaf9190a57d9ca2c6e197dcfeed5276c7e6d77f4282893aa5ca380035b6e967f43daf9899b451ca7ae3e8b5668c
+  data.tar.gz: eefe5088fdfc55365c237f5b5fa84472b50352b61a21f7f88302e7bf156f52f4d40b9021da44cb93d152a3918d57ecf262781b77f39c093a3d15490864dcf8a9

data/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Tyler Rhodes
+
+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/lib/mismatch_inspectable/array_formatter.rb

@@ -0,0 +1,17 @@
+module MismatchInspectable
+  class ArrayFormatter
+    attr_reader :mismatches
+
+    def initialize
+      @mismatches = []
+    end
+
+    def add_mismatch(prefix, attribute, curr_val, other_val)
+      @mismatches << [prefix + attribute.to_s, curr_val, other_val]
+    end
+
+    def merge_mismatches(nested_mismatches)
+      @mismatches.concat(nested_mismatches)
+    end
+  end
+end

data/lib/mismatch_inspectable/deep_merge.rb

@@ -0,0 +1,13 @@
+module DeepMerge
+  def deep_merge!(other_hash)
+    other_hash&.each do |key, value|
+      if self[key].is_a?(Hash) && value.is_a?(Hash)
+        self[key].extend(DeepMerge) unless self[key].respond_to?(:deep_merge!)
+        self[key].deep_merge!(value)
+      else
+        self[key] = value
+      end
+    end
+    self
+  end
+end

data/lib/mismatch_inspectable/hash_formatter.rb

@@ -0,0 +1,17 @@
+module MismatchInspectable
+  class HashFormatter
+    attr_reader :mismatches
+
+    def initialize
+      @mismatches = Hash.new { |hash, key| hash[key] = {} }
+    end
+
+    def add_mismatch(prefix, attribute, curr_val, other_val)
+      @mismatches[prefix + attribute.to_s] = [curr_val, other_val]
+    end
+
+    def merge_mismatches(nested_mismatches)
+      nested_mismatches.each { |k, v| mismatches[k] = v }
+    end
+  end
+end

data/lib/mismatch_inspectable/mismatch_inspectable.rb

@@ -0,0 +1,79 @@
+require_relative 'hash_formatter'
+require_relative 'array_formatter'
+require_relative 'object_formatter'
+
+module MismatchInspectable
+  class << self
+    def included(base)
+      class << base
+        include ClassMethods
+      end
+    end
+  end
+
+  module ClassMethods
+    attr_reader :compare_methods
+
+    def inspect_mismatch_for(*methods)
+      @compare_methods = methods
+    end
+  end
+
+  def inspect_mismatch(other, recursive: false, include_class: true, prefix: '', format: :array)
+    return if self.class != other.class
+
+    formatter = case format
+                when :hash then HashFormatter.new
+                when :array then ArrayFormatter.new
+                when :object then ObjectFormatter.new
+                else raise ArgumentError, "Invalid format: #{format}"
+                end
+
+    process_attributes(formatter, other, recursive, include_class, prefix, format)
+    formatter.mismatches
+  end
+
+  def compare_methods
+    self.class.compare_methods
+  end
+
+  private
+
+  def process_attributes(formatter, other, recursive, include_class, prefix, format)
+    self.class.compare_methods.each do |attribute|
+      curr_val = __send__(attribute)
+      other_val = other.__send__(attribute)
+
+      if recursive && both_are_inspectable?(curr_val, other_val)
+        process_recursive(formatter, curr_val, other_val, include_class, prefix, attribute, format)
+      elsif curr_val != other_val
+        prefix = update_prefix(include_class, prefix)
+        formatter.add_mismatch(prefix, attribute, curr_val, other_val)
+      end
+    end
+  end
+
+  def both_are_inspectable?(curr_val, other_val)
+    curr_val.respond_to?(:inspect_mismatch) && other_val.respond_to?(:inspect_mismatch)
+  end
+
+  def process_recursive(formatter, curr_val, other_val, include_class, prefix, attribute, format)
+    nested_mismatches = curr_val.inspect_mismatch(
+      other_val,
+      recursive: true,
+      include_class: include_class,
+      prefix: prefix + "#{attribute}.",
+      format: format
+    )
+
+    formatter.merge_mismatches(nested_mismatches) unless nested_mismatches?(nested_mismatches)
+  end
+
+  def update_prefix(include_class, prefix)
+    include_class ? "#{prefix}#{self.class}#" : prefix
+  end
+
+  def nested_mismatches?(mismatches)
+    mismatches.nil? || mismatches.empty?
+  end
+end

data/lib/mismatch_inspectable/object_formatter.rb

@@ -0,0 +1,25 @@
+require_relative 'deep_merge'
+
+class ObjectFormatter
+  def initialize
+    @mismatches = {}.extend(DeepMerge)
+  end
+
+  attr_reader :mismatches
+
+  def add_mismatch(prefix, attribute, curr_val, other_val)
+    prefix_parts = prefix.split('.').flat_map { |part| part.split('#') }.collect(&:to_sym)
+    curr = mismatches
+
+    prefix_parts.each do |part|
+      curr[part] ||= {}
+      curr = curr[part]
+    end
+
+    curr[attribute] = [curr_val, other_val]
+  end
+
+  def merge_mismatches(nested_mismatches)
+    mismatches.deep_merge!(nested_mismatches)
+  end
+end

data/lib/mismatch_inspectable.rb

@@ -0,0 +1 @@
+require_relative 'mismatch_inspectable/mismatch_inspectable'

data/spec/examples.txt

@@ -0,0 +1,22 @@
+example_id                                                 | status | run_time        |
+---------------------------------------------------------- | ------ | --------------- |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:1:1]           | passed | 0.0009 seconds  |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:1]         | passed | 0.00075 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:2:1]       | passed | 0.00015 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:1:1]   | passed | 0.0002 seconds  |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:1:2:1] | passed | 0.00016 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:2:1]   | passed | 0.00015 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:2:2:1] | passed | 0.00016 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:2:1]     | passed | 0.00013 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:1:1]       | passed | 0.00011 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:2:1]       | passed | 0.00072 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:3:1]       | passed | 0.00036 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:1:1:1] | passed | 0.00023 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:1:2:1] | passed | 0.00018 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:1:3:1] | passed | 0.00015 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:2:1:1] | passed | 0.00023 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:2:2:1] | passed | 0.00026 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:2:3:1] | passed | 0.00061 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:2:1:1]   | passed | 0.00016 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:2:2:1]   | passed | 0.00034 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:2:3:1]   | passed | 0.00025 seconds |

data/spec/lib/mismatch_inspectable_spec.rb

@@ -0,0 +1,313 @@
+require 'rspec'
+require 'spec_helper'
+require 'mismatch_inspectable/mismatch_inspectable'
+
+class TestClass
+  include MismatchInspectable
+
+  attr_accessor :name, :age, :address, :nested
+
+  inspect_mismatch_for :name, :age, :address, :nested
+end
+
+class NestedTestClass
+  include MismatchInspectable
+
+  attr_accessor :city, :country
+
+  inspect_mismatch_for :city, :country
+end
+
+RSpec.describe MismatchInspectable do
+  let(:object1) { TestClass.new }
+  let(:object2) { TestClass.new }
+  let(:format) { :array }
+  let(:recursive) { false }
+
+  let(:name) { 'Tyler' }
+  let(:age) { 29 }
+  let(:address) { '123 Cool St' }
+
+  before do
+    object1.name = name
+    object1.age = age
+    object1.address = address
+
+    object2.name = name
+    object2.age = age
+    object2.address = address
+  end
+
+  describe '#inspect_mismatch' do
+    context 'when objects are of different classes' do
+      let(:object3) { Object.new }
+
+      it 'returns nil' do
+        expect(object1.inspect_mismatch(object3)).to be_nil
+      end
+    end
+
+    context 'when objects are of the same class' do
+      context 'with top level attributes that match' do
+        it 'returns an empty array' do
+          expect(object1.inspect_mismatch(object1)).to eq([])
+        end
+
+        context 'when format is set to :hash' do
+          let(:format) { :hash }
+
+          it 'returns an empty hash' do
+            expect(object1.inspect_mismatch(object1, format: format)).to eq({})
+          end
+        end
+
+        context 'with nested inspectable attributes' do
+          let(:recursive) { true }
+
+          context 'when objects have nested attributes with the same class' do
+            let(:nested1) { NestedTestClass.new }
+            let(:nested2) { NestedTestClass.new }
+
+            let(:city) { 'ATX' }
+            let(:country) { 'USA' }
+
+            before do
+              nested1.city = city
+              nested1.country = country
+
+              nested2.city = city
+              nested2.country = country
+
+              object1.nested = nested1
+              object2.nested = nested2
+            end
+
+            context 'when nested attributes match' do
+              it 'returns an empty array' do
+                expect(object1.inspect_mismatch(object2, recursive: recursive)).to eq([])
+              end
+
+              context 'when format is set to :hash' do
+                let(:format) { :hash }
+                it 'returns an empty hash' do
+                  expect(object1.inspect_mismatch(object2, format: format, recursive: recursive)).to eq({})
+                end
+              end
+            end
+
+            context 'when nested attributes have different values' do
+              before { nested2.city = 'Phoenix' }
+
+              it 'returns an array of mismatched nested attributes with recursive flag enabled' do
+                expected = [
+                  ['nested.NestedTestClass#city', 'ATX', 'Phoenix']
+                ]
+                expect(object1.inspect_mismatch(object2, recursive: recursive)).to eq(expected)
+              end
+
+              context 'when format is set to :hash' do
+                let(:format) { :hash }
+                it 'returns a hash of mismatched nested attributes with recursive flag enabled' do
+                  expected = {
+                    'nested.NestedTestClass#city' => %w[ATX Phoenix]
+                  }
+                  expect(object1.inspect_mismatch(object2, format: format, recursive: recursive)).to eq(expected)
+                end
+              end
+            end
+          end
+
+          context 'when nested attributes have different classes' do
+            let(:nested1) { NestedTestClass.new }
+            let(:nested2) { TestClass.new }
+
+            before do
+              object1.nested = nested1
+              object2.nested = nested2
+            end
+
+            it 'returns nil for mismatched nested attribute with recursive flag enabled' do
+              expect(object1.inspect_mismatch(object2, recursive: recursive)).to eq([])
+            end
+          end
+        end
+      end
+
+      context "with top level attributes that don't match" do
+        before { object2.age = 30 }
+
+        context 'when format is set to :array (default)' do
+          it 'returns an array of mismatched attributes' do
+            expected = [
+              ['TestClass#age', 29, 30]
+            ]
+            expect(object1.inspect_mismatch(object2)).to eq(expected)
+          end
+        end
+
+        context 'when format is set to :hash' do
+          let(:format) { :hash }
+          it 'returns a hash of mismatched attributes' do
+            expected = {
+              'TestClass#age' => [29, 30]
+            }
+            expect(object1.inspect_mismatch(object2, format: format)).to eq(expected)
+          end
+        end
+
+        context 'when format is set to :object' do
+          let(:format) { :object }
+          it 'returns an object of mismatched attributes' do
+            expected = {
+              TestClass: {
+                age: [29, 30]
+              }
+            }
+            expect(object1.inspect_mismatch(object2, format: format)).to eq(expected)
+          end
+        end
+
+        context 'with nested inspectable attributes' do
+          let(:recursive) { true }
+          context 'when objects have nested attributes with the same class' do
+            let(:nested1) { NestedTestClass.new }
+            let(:nested2) { NestedTestClass.new }
+
+            let(:city) { 'ATX' }
+            let(:country) { 'USA' }
+
+            before do
+              nested1.city = city
+              nested1.country = country
+
+              nested2.city = 'Phoenix'
+              nested2.country = country
+
+              object1.nested = nested1
+              object2.nested = nested1
+            end
+
+            context 'when nested attributes match' do
+              context 'when format is set to :array (default)' do
+                it 'returns the top-level mismatched attributes' do
+                  expected = [
+                    ['TestClass#age', 29, 30]
+                  ]
+                  expect(object1.inspect_mismatch(object2)).to eq(expected)
+                end
+              end
+
+              context 'when format is set to :hash' do
+                let(:format) { :hash }
+                it 'returns the top-level mismatched attributes' do
+                  expected = {
+                    'TestClass#age' => [29, 30]
+                  }
+                  expect(object1.inspect_mismatch(object2, format: format)).to eq(expected)
+                end
+              end
+
+              context 'when format is set to :object' do
+                let(:format) { :object }
+                it 'returns the top-level mismatched attributes' do
+                  expected = {
+                    TestClass: {
+                      age: [29, 30]
+                    }
+                  }
+                  expect(object1.inspect_mismatch(object2, format: format)).to eq(expected)
+                end
+              end
+            end
+
+            context 'when nested attributes have different values' do
+              before { object2.nested = nested2 }
+
+              context 'when format is set to :array (default)' do
+                it 'returns an array of mismatched nested attributes with recursive flag enabled' do
+                  expected = [
+                    ['TestClass#age', 29, 30],
+                    ['TestClass#nested.NestedTestClass#city', 'ATX', 'Phoenix']
+                  ]
+                  expect(object1.inspect_mismatch(object2, recursive: true)).to eq(expected)
+                end
+              end
+
+              context 'when format is set to :hash' do
+                let(:format) { :hash }
+                it 'returns a hash of mismatched nested attributes with recursive flag enabled' do
+                  expected = {
+                    'TestClass#age' => [29, 30],
+                    'TestClass#nested.NestedTestClass#city' => %w[ATX Phoenix]
+                  }
+                  expect(object1.inspect_mismatch(object2, recursive: recursive, format: format)).to eq(expected)
+                end
+              end
+
+              context 'when format is set to :object' do
+                let(:format) { :object }
+                it 'returns an object of mismatched nested attributes with recursive flag enabled' do
+                  expected = {
+                    TestClass: {
+                      age: [29, 30],
+                      nested: {
+                        NestedTestClass: {
+                          city: %w[ATX Phoenix]
+                        }
+                      }
+                    }
+                  }
+                  expect(object1.inspect_mismatch(object2, recursive: recursive, format: format)).to eq(expected)
+                end
+              end
+            end
+          end
+
+          context 'when nested attributes have different classes' do
+            let(:nested1) { NestedTestClass.new }
+            let(:nested2) { TestClass.new }
+
+            before do
+              object1.nested = nested1
+              object2.nested = nested2
+            end
+
+            context 'when format is set to :array (default)' do
+              it 'returns nil for mismatched nested attribute with recursive flag enabled' do
+                expect(object1.inspect_mismatch(object2, recursive: recursive)).to eq(
+                  [
+                    ['TestClass#age', 29, 30]
+                  ]
+                )
+              end
+            end
+
+            context 'when format is set to :hash' do
+              let(:format) { :hash }
+              it 'returns nil for mismatched nested attribute with recursive flag enabled' do
+                expect(object1.inspect_mismatch(object2, recursive: recursive, format: format)).to eq(
+                  {
+                    'TestClass#age' => [29, 30]
+                  }
+                )
+              end
+            end
+
+            context 'when format is set to :object' do
+              let(:format) { :object }
+              it 'returns nil for mismatched nested attribute with recursive flag enabled' do
+                expect(object1.inspect_mismatch(object2, recursive: recursive, format: format)).to eq(
+                  {
+                    TestClass: {
+                      age: [29, 30]
+                    }
+                  }
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,98 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+  #   # This allows you to limit a spec run to individual examples or groups
+  #   # you care about by tagging them with `:focus` metadata. When nothing
+  #   # is tagged with `:focus`, all examples get run. RSpec also provides
+  #   # aliases for `it`, `describe`, and `context` that include `:focus`
+  #   # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  #   config.filter_run_when_matching :focus
+  #
+  #   # Allows RSpec to persist some state between runs in order to support
+  #   # the `--only-failures` and `--next-failure` CLI options. We recommend
+  #   # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+  #
+  #   # Limits the available syntax to the non-monkey patched syntax that is
+  #   # recommended. For more details, see:
+  #   #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  #   config.disable_monkey_patching!
+  #
+  #   # This setting enables warnings. It's recommended, but in some cases may
+  #   # be too noisy due to issues in dependencies.
+  #   config.warnings = true
+  #
+  #   # Many RSpec users commonly either run the entire suite or an individual
+  #   # file, and it's useful to allow more verbose output when running an
+  #   # individual spec file.
+  #   if config.files_to_run.one?
+  #     # Use the documentation formatter for detailed output,
+  #     # unless a formatter has already been configured
+  #     # (e.g. via a command-line flag).
+  #     config.default_formatter = "doc"
+  #   end
+  #
+  #   # Print the 10 slowest examples and example groups at the
+  #   # end of the spec run, to help surface which specs are running
+  #   # particularly slow.
+  #   config.profile_examples = 10
+  #
+  #   # Run specs in random order to surface order dependencies. If you find an
+  #   # order dependency and want to debug it, you can fix the order by providing
+  #   # the seed, which is printed after each run.
+  #   #     --seed 1234
+  #   config.order = :random
+  #
+  #   # Seed global randomization in this process using the `--seed` CLI option.
+  #   # Setting this allows you to use `--seed` to deterministically reproduce
+  #   # test failures related to randomization by passing the same `--seed` value
+  #   # as the one that triggered the failure.
+  #   Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: mismatch-inspectable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tyler Rhodes
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+description: A library that includes a module that can print mismatched values for
+  any class that includes it. Supports recursive inspection of nested objects.
+email:
+- tyler.rhodes@aya.yale.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- lib/mismatch_inspectable.rb
+- lib/mismatch_inspectable/array_formatter.rb
+- lib/mismatch_inspectable/deep_merge.rb
+- lib/mismatch_inspectable/hash_formatter.rb
+- lib/mismatch_inspectable/mismatch_inspectable.rb
+- lib/mismatch_inspectable/object_formatter.rb
+- spec/examples.txt
+- spec/lib/mismatch_inspectable_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/tyleCaineRhodes/mismatch-inspectable
+licenses:
+- MIT
+metadata: {}
+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: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: A library for easily printing and debugging mismatched values
+test_files:
+- spec/examples.txt
+- spec/lib/mismatch_inspectable_spec.rb
+- spec/spec_helper.rb