mismatch-inspectable 0.1.0 → 0.1.2

checksums.yaml

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

data/README.md

@@ -0,0 +1,217 @@
+The `MismatchInspectable` module provides a way to compare two objects and find the differences in their attributes. The module can be included in any class to compare objects of that class, and it provides options for the output format, recursion, and inclusion of class names in the output.
+
+
+- [Usage](#usage)
+- [Options](#options)
+  - [format](#format)
+  - [include\_class (default: true)](#include_class-default-true)
+  - [recursive (default: false)](#recursive-default-false)
+- [Examples](#examples)
+  - [Example 1: Basic usage](#example-1-basic-usage)
+  - [Example 2: Using different formats](#example-2-using-different-formats)
+  - [Example 3: Comparing nested objects](#example-3-comparing-nested-objects)
+  - [Example 4: Excluding class from output](#example-4-excluding-class-from-output)
+  - [Example 5: Comparing objects with recursive set to false](#example-5-comparing-objects-with-recursive-set-to-false)
+  - [Example 6: Comparing objects when one is null](#example-6-comparing-objects-when-one-is-null)
+
+***
+## Usage
+
+To use `MismatchInspectable`, first include it in your class and list the attributes you want to compare using the `inspect_mismatch_for` method.
+
+ ```ruby
+class Thing
+  include MismatchInspectable
+
+  inspect_mismatch_for :color, :shape, :is_cool
+
+  def initialize(color, shape, is_cool)
+    @color = color
+    @shape = shape
+    @is_cool = is_cool
+  end
+
+  # Your class implementation
+end
+```
+
+Then, to compare two objects of the class, call the inspect_mismatch method on one of the objects and pass the other object as an argument.
+
+```ruby
+thing1 = Thing.new("red", "circle", true)
+thing2 = Thing.new("blue", "circle", false)
+
+mismatch = thing1.inspect_mismatch(thing2)
+```
+
+***
+## Options
+
+### format
+You can choose from three different output formats: :array, :hash, or :object. The default format is :array.
+
+
+• :array format example:
+
+```ruby
+[
+  ['Thing#color', 'red', 'blue'],
+  ['Thing#is_cool', true, false]
+]
+```
+
+• :hash format example:
+```ruby
+{
+  'Thing#color' => ['red', 'blue'],
+  'Thing#is_cool' => [true, false]
+}
+```
+
+:object format example:
+```ruby
+{
+  Thing: {
+    color: ['red', 'blue'],
+    is_cool: [true, false]
+  }
+}
+```
+
+### include_class (default: true)
+
+ When this option is set to true, the comparison will include the class in the
+ output for the objects being compared. If the objects being compared have
+ different classes, a mismatch will always be reported, regardless of this flag
+ being set. If set to false, you will simply not see the class names in the
+ output.
+
+
+### recursive (default: false)
+When this option is set to true, the comparison will be performed recursively on
+all instance variables which are passed to `inspect_mismatch_for`. If any of the
+instance variables are also objects that include the `MismatchInspectable`
+module, their `inspect_mismatch` method will be called with the same options. If
+set to false,the comparison will only be performed on the top-level instance
+variables which are passed to `inspect_mismatch_for` and will not delve deeper
+into the objects.  Instead it will do a simple comparison of said instance
+variables.
+
+***
+## Examples
+### Example 1: Basic usage
+
+```ruby
+require "mismatch_inspectable"
+
+class Car
+  include MismatchInspectable
+
+  inspect_mismatch_for :make, :model, :year
+
+  def initialize(make, model, year)
+    @make = make
+    @model = model
+    @year = year
+  end
+
+  attr_accessor :make, :model, :year
+end
+
+car1 = Car.new("Toyota", "Camry", 2020)
+car2 = Car.new("Toyota", "Corolla", 2020)
+mismatches = car1.inspect_mismatch(car2)
+
+# Output with default format: array
+# [["Car#model", "Camry", "Corolla"]]
+```
+
+
+### Example 2: Using different formats
+
+```ruby
+mismatches_hash = car1.inspect_mismatch(car2, format: :hash)
+
+# Output with format: hash
+# {"Car#model" => ["Camry", "Corolla"]}
+
+mismatches_object = car1.inspect_mismatch(car2, format: :object)
+
+# Output with format: object
+# {Car: {model: ["Camry", "Corolla"]}}
+```
+
+### Example 3: Comparing nested objects
+
+```ruby
+class Owner
+  include MismatchInspectable
+
+  inspect_mismatch_for :name, :age
+
+  def initialize(name, age)
+    @name = name
+    @age = age
+  end
+
+  attr_accessor :name, :age
+end
+
+class Pet
+  include MismatchInspectable
+
+  inspect_mismatch_for :name, :species, :owner
+
+  def initialize(name, species, owner)
+    @name = name
+    @species = species
+    @owner = owner
+  end
+
+  attr_accessor :name, :species, :owner
+end
+
+owner1 = Owner.new("Alice", 30)
+owner2 = Owner.new("Bob", 35)
+pet1 = Pet.new("Fluffy", "cat", owner1)
+pet2 = Pet.new("Fluffy", "cat", owner2)
+
+mismatches = pet1.inspect_mismatch(pet2, recursive: true)
+
+# Output with recursive: true
+# [["Pet#owner.Owner#name", "Alice", "Bob"], ["Pet#owner.Owner#age", 30, 35]]
+```
+
+
+### Example 4: Excluding class from output
+```ruby
+mismatches_no_class = pet1.inspect_mismatch(pet2, recursive: true, include_class: false)
+
+# Output with include_class: false
+# [["owner.name", "Alice", "Bob"], ["owner.age", 30, 35]]
+```
+
+### Example 5: Comparing objects with recursive set to false
+
+```ruby
+pet5 = Pet.new("Max", "dog", owner1)
+pet6 = Pet.new("Max", "dog", owner2)
+
+mismatches_non_recursive = pet5.inspect_mismatch(pet6, recursive: false)
+
+# Output with recursive: false and non-nil owners
+# [["Pet#owner", #<Owner:0x00007fe3d206d3c8 @name="Alice", @age=30>, #<Owner:0x00007fe3d207d3c8 @name="Bob", @age=35>]]
+```
+
+### Example 6: Comparing objects when one is null
+
+```ruby
+owner3 = Owner.new("Charlie", 40)
+pet3 = Pet.new("Buddy", "dog", owner3)
+pet4 = Pet.new("Buddy", "dog", nil)
+
+mismatches_owner_nil = pet3.inspect_mismatch(pet4, recursive: true)
+
+# Output with recursive: true and one nil owner
+# [["Pet#owner", #<Owner:0x00007fe3d206d3c8 @name="Charlie", @age=40>, nil]]
+```

data/lib/mismatch_inspectable/mismatch_inspectable.rb

@@ -1,14 +1,10 @@
-require_relative 'hash_formatter'
-require_relative 'array_formatter'
-require_relative 'object_formatter'
+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
+  def self.included(target_class)
+    target_class.extend ClassMethods
   end
 
   module ClassMethods
@@ -19,15 +15,16 @@ module MismatchInspectable
     end
   end
 
-  def inspect_mismatch(other, recursive: false, include_class: true, prefix: '', format: :array)
+  class MissingCompareMethodsError < StandardError
+    def initialize(klass)
+      super("The class #{klass} does not have methods to compare. Define methods with `inspect_mismatch_for`.")
+    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
+    formatter = select_formatter(format)
 
     process_attributes(formatter, other, recursive, include_class, prefix, format)
     formatter.mismatches
@@ -39,8 +36,20 @@ module MismatchInspectable
 
   private
 
+  def select_formatter(format)
+    case format
+    when :hash then HashFormatter.new
+    when :array then ArrayFormatter.new
+    when :object then ObjectFormatter.new
+    else raise ArgumentError, "Invalid format: #{format}"
+    end
+  end
+
+  # rubocop:disable Metrics/ParameterLists
   def process_attributes(formatter, other, recursive, include_class, prefix, format)
-    self.class.compare_methods.each do |attribute|
+    raise MissingCompareMethodsError if compare_methods.nil?
+
+    compare_methods.each do |attribute|
       curr_val = __send__(attribute)
       other_val = other.__send__(attribute)
 
@@ -61,19 +70,26 @@ module MismatchInspectable
     nested_mismatches = curr_val.inspect_mismatch(
       other_val,
       recursive: true,
-      include_class: include_class,
-      prefix: prefix + "#{attribute}.",
-      format: format
+      include_class:,
+      prefix: "#{prefix}#{attribute}.",
+      format:
     )
 
-    formatter.merge_mismatches(nested_mismatches) unless nested_mismatches?(nested_mismatches)
+    formatter.merge_mismatches(nested_mismatches) unless no_nested_mismatches?(nested_mismatches)
   end
+  # rubocop:enable Metrics/ParameterLists
 
   def update_prefix(include_class, prefix)
-    include_class ? "#{prefix}#{self.class}#" : prefix
+    comparable_prefix = get_comparable_prefix(prefix)
+    include_class && comparable_prefix != "#{self.class}#" ? "#{prefix}#{self.class}#" : prefix
   end
 
-  def nested_mismatches?(mismatches)
+  def no_nested_mismatches?(mismatches)
     mismatches.nil? || mismatches.empty?
   end
+
+  def get_comparable_prefix(prefix)
+    prefixes = prefix.split(".")
+    prefixes.length >= 2 ? prefixes[-1] : prefix
+  end
 end

data/lib/mismatch_inspectable/object_formatter.rb

@@ -1,4 +1,4 @@
-require_relative 'deep_merge'
+require_relative "deep_merge"
 
 class ObjectFormatter
   def initialize
@@ -8,7 +8,7 @@ class ObjectFormatter
   attr_reader :mismatches
 
   def add_mismatch(prefix, attribute, curr_val, other_val)
-    prefix_parts = prefix.split('.').flat_map { |part| part.split('#') }.collect(&:to_sym)
+    prefix_parts = prefix.split(".").flat_map { |part| part.split("#") }.collect(&:to_sym)
     curr = mismatches
 
     prefix_parts.each do |part|

data/lib/mismatch_inspectable/version.rb

@@ -0,0 +1,3 @@
+module MismatchInspectable
+  VERSION = "0.1.2".freeze
+end

data/lib/mismatch_inspectable.rb

@@ -1 +1 @@
-require_relative 'mismatch_inspectable/mismatch_inspectable'
+require_relative "mismatch_inspectable/mismatch_inspectable"

data/spec/examples.txt

@@ -1,22 +1,24 @@
 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 |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:1:1]           | passed | 0.00088 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:1]         | passed | 0.00045 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:2:1]       | passed | 0.00012 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:1:1]   | passed | 0.00146 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:1:2:1] | passed | 0.00014 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:2:1]   | passed | 0.00012 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:2:2:1] | passed | 0.00013 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:2:1]     | passed | 0.0001 seconds  |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:1:1]       | passed | 0.00009 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:2:1]       | passed | 0.0001 seconds  |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:3:1]       | passed | 0.00011 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:1:1:1] | passed | 0.00012 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:1:2:1] | passed | 0.00011 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:1:3:1] | passed | 0.00033 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:2:1:1] | passed | 0.00012 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:2:2:1] | passed | 0.00013 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:2:3:1] | passed | 0.00015 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:2:1:1]   | passed | 0.0001 seconds  |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:2:2:1]   | passed | 0.00011 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:2:3:1]   | passed | 0.00011 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:3:1:1]   | passed | 0.00017 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:3:2:1]   | passed | 0.0002 seconds  |

data/spec/lib/mismatch_inspectable_spec.rb

@@ -1,6 +1,6 @@
-require 'rspec'
-require 'spec_helper'
-require 'mismatch_inspectable/mismatch_inspectable'
+require "rspec"
+require "spec_helper"
+require "mismatch_inspectable"
 
 class TestClass
   include MismatchInspectable
@@ -24,9 +24,9 @@ RSpec.describe MismatchInspectable do
   let(:format) { :array }
   let(:recursive) { false }
 
-  let(:name) { 'Tyler' }
+  let(:name) { "Tyler" }
   let(:age) { 29 }
-  let(:address) { '123 Cool St' }
+  let(:address) { "123 Cool St" }
 
   before do
     object1.name = name
@@ -38,38 +38,38 @@ RSpec.describe MismatchInspectable do
     object2.address = address
   end
 
-  describe '#inspect_mismatch' do
-    context 'when objects are of different classes' do
+  describe "#inspect_mismatch" do
+    context "when objects are of different classes" do
       let(:object3) { Object.new }
 
-      it 'returns nil' do
+      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
+    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
+        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({})
+          it "returns an empty hash" do
+            expect(object1.inspect_mismatch(object1, format:)).to eq({})
           end
         end
 
-        context 'with nested inspectable attributes' do
+        context "with nested inspectable attributes" do
           let(:recursive) { true }
 
-          context 'when objects have nested attributes with the same class' do
+          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' }
+            let(:city) { "ATX" }
+            let(:country) { "USA" }
 
             before do
               nested1.city = city
@@ -82,42 +82,42 @@ RSpec.describe MismatchInspectable do
               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([])
+            context "when nested attributes match" do
+              it "returns an empty array" do
+                expect(object1.inspect_mismatch(object2, recursive:)).to eq([])
               end
 
-              context 'when format is set to :hash' do
+              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({})
+                it "returns an empty hash" do
+                  expect(object1.inspect_mismatch(object2, format:, recursive:)).to eq({})
                 end
               end
             end
 
-            context 'when nested attributes have different values' do
-              before { nested2.city = 'Phoenix' }
+            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
+              it "returns an array of mismatched nested attributes with recursive flag enabled" do
                 expected = [
-                  ['nested.NestedTestClass#city', 'ATX', 'Phoenix']
+                  ["nested.NestedTestClass#city", "ATX", "Phoenix"]
                 ]
-                expect(object1.inspect_mismatch(object2, recursive: recursive)).to eq(expected)
+                expect(object1.inspect_mismatch(object2, recursive:)).to eq(expected)
               end
 
-              context 'when format is set to :hash' do
+              context "when format is set to :hash" do
                 let(:format) { :hash }
-                it 'returns a hash of mismatched nested attributes with recursive flag enabled' do
+                it "returns a hash of mismatched nested attributes with recursive flag enabled" do
                   expected = {
-                    'nested.NestedTestClass#city' => %w[ATX Phoenix]
+                    "nested.NestedTestClass#city" => %w[ATX Phoenix]
                   }
-                  expect(object1.inspect_mismatch(object2, format: format, recursive: recursive)).to eq(expected)
+                  expect(object1.inspect_mismatch(object2, format:, recursive:)).to eq(expected)
                 end
               end
             end
           end
 
-          context 'when nested attributes have different classes' do
+          context "when nested attributes have different classes" do
             let(:nested1) { NestedTestClass.new }
             let(:nested2) { TestClass.new }
 
@@ -126,8 +126,8 @@ RSpec.describe MismatchInspectable do
               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([])
+            it "returns nil for mismatched nested attribute with recursive flag enabled" do
+              expect(object1.inspect_mismatch(object2, recursive:)).to eq([])
             end
           end
         end
@@ -136,117 +136,117 @@ RSpec.describe MismatchInspectable do
       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
+        context "when format is set to :array (default)" do
+          it "returns an array of mismatched attributes" do
             expected = [
-              ['TestClass#age', 29, 30]
+              ["TestClass#age", 29, 30]
             ]
             expect(object1.inspect_mismatch(object2)).to eq(expected)
           end
         end
 
-        context 'when format is set to :hash' do
+        context "when format is set to :hash" do
           let(:format) { :hash }
-          it 'returns a hash of mismatched attributes' do
+          it "returns a hash of mismatched attributes" do
             expected = {
-              'TestClass#age' => [29, 30]
+              "TestClass#age" => [29, 30]
             }
-            expect(object1.inspect_mismatch(object2, format: format)).to eq(expected)
+            expect(object1.inspect_mismatch(object2, format:)).to eq(expected)
           end
         end
 
-        context 'when format is set to :object' do
+        context "when format is set to :object" do
           let(:format) { :object }
-          it 'returns an object of mismatched attributes' do
+          it "returns an object of mismatched attributes" do
             expected = {
               TestClass: {
                 age: [29, 30]
               }
             }
-            expect(object1.inspect_mismatch(object2, format: format)).to eq(expected)
+            expect(object1.inspect_mismatch(object2, format:)).to eq(expected)
           end
         end
 
-        context 'with nested inspectable attributes' do
+        context "with nested inspectable attributes" do
           let(:recursive) { true }
-          context 'when objects have nested attributes with the same class' do
+          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' }
+            let(:city) { "ATX" }
+            let(:country) { "USA" }
 
             before do
               nested1.city = city
               nested1.country = country
 
-              nested2.city = 'Phoenix'
+              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
+            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]
+                    ["TestClass#age", 29, 30]
                   ]
                   expect(object1.inspect_mismatch(object2)).to eq(expected)
                 end
               end
 
-              context 'when format is set to :hash' do
+              context "when format is set to :hash" do
                 let(:format) { :hash }
-                it 'returns the top-level mismatched attributes' do
+                it "returns the top-level mismatched attributes" do
                   expected = {
-                    'TestClass#age' => [29, 30]
+                    "TestClass#age" => [29, 30]
                   }
-                  expect(object1.inspect_mismatch(object2, format: format)).to eq(expected)
+                  expect(object1.inspect_mismatch(object2, format:)).to eq(expected)
                 end
               end
 
-              context 'when format is set to :object' do
+              context "when format is set to :object" do
                 let(:format) { :object }
-                it 'returns the top-level mismatched attributes' do
+                it "returns the top-level mismatched attributes" do
                   expected = {
                     TestClass: {
                       age: [29, 30]
                     }
                   }
-                  expect(object1.inspect_mismatch(object2, format: format)).to eq(expected)
+                  expect(object1.inspect_mismatch(object2, format:)).to eq(expected)
                 end
               end
             end
 
-            context 'when nested attributes have different values' do
+            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
+              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']
+                    ["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
+              context "when format is set to :hash" do
                 let(:format) { :hash }
-                it 'returns a hash of mismatched nested attributes with recursive flag enabled' do
+                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]
+                    "TestClass#age" => [29, 30],
+                    "TestClass#nested.NestedTestClass#city" => %w[ATX Phoenix]
                   }
-                  expect(object1.inspect_mismatch(object2, recursive: recursive, format: format)).to eq(expected)
+                  expect(object1.inspect_mismatch(object2, recursive:, format:)).to eq(expected)
                 end
               end
 
-              context 'when format is set to :object' do
+              context "when format is set to :object" do
                 let(:format) { :object }
-                it 'returns an object of mismatched nested attributes with recursive flag enabled' do
+                it "returns an object of mismatched nested attributes with recursive flag enabled" do
                   expected = {
                     TestClass: {
                       age: [29, 30],
@@ -257,13 +257,13 @@ RSpec.describe MismatchInspectable do
                       }
                     }
                   }
-                  expect(object1.inspect_mismatch(object2, recursive: recursive, format: format)).to eq(expected)
+                  expect(object1.inspect_mismatch(object2, recursive:, format:)).to eq(expected)
                 end
               end
             end
           end
 
-          context 'when nested attributes have different classes' do
+          context "when nested attributes have different classes" do
             let(:nested1) { NestedTestClass.new }
             let(:nested2) { TestClass.new }
 
@@ -272,31 +272,31 @@ RSpec.describe MismatchInspectable do
               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(
+            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:)).to eq(
                   [
-                    ['TestClass#age', 29, 30]
+                    ["TestClass#age", 29, 30]
                   ]
                 )
               end
             end
 
-            context 'when format is set to :hash' do
+            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(
+              it "returns nil for mismatched nested attribute with recursive flag enabled" do
+                expect(object1.inspect_mismatch(object2, recursive:, format:)).to eq(
                   {
-                    'TestClass#age' => [29, 30]
+                    "TestClass#age" => [29, 30]
                   }
                 )
               end
             end
 
-            context 'when format is set to :object' do
+            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(
+              it "returns nil for mismatched nested attribute with recursive flag enabled" do
+                expect(object1.inspect_mismatch(object2, recursive:, format:)).to eq(
                   {
                     TestClass: {
                       age: [29, 30]
@@ -306,6 +306,106 @@ RSpec.describe MismatchInspectable do
               end
             end
           end
+
+          context "with multiple levels of nested inspectable attributes" do
+            # rubocop:disable Lint/ConstantDefinitionInBlock
+            class Thing
+              include MismatchInspectable
+
+              inspect_mismatch_for :color, :shape, :is_cool, :nested_thing
+
+              def initialize(color: nil, shape: nil, is_cool: nil, nested_thing: nil)
+                @color = color
+                @shape = shape
+                @is_cool = is_cool
+                @nested_thing = nested_thing
+              end
+
+              def inspect
+                "<Thing>"
+              end
+
+              attr_accessor :color, :shape, :is_cool, :nested_thing
+            end
+            # rubocop:enable Lint/ConstantDefinitionInBlock
+
+            let(:thing1) do
+              Thing.new(
+                color: "blue",
+                shape: "square",
+                is_cool: false,
+                nested_thing: Thing.new(
+                  color: "blue",
+                  shape: "oval",
+                  is_cool: true,
+                  nested_thing: Thing.new(
+                    color: "silver",
+                    shape: "oval",
+                    is_cool: true
+                  )
+                )
+              )
+            end
+
+            let(:thing2) do
+              Thing.new(
+                color: "green",
+                shape: "oval",
+                is_cool: false,
+                nested_thing: Thing.new(
+                  color: "red",
+                  shape: "another shape",
+                  is_cool: true,
+                  nested_thing: Thing.new(
+                    color: "blue",
+                    shape: "oval",
+                    is_cool: false
+                  )
+                )
+              )
+            end
+            context "with recursive flag disabled" do
+              it "returns the mismatched top-level attributes" do
+                expect(thing1.inspect_mismatch(thing2, format: :object)).to eq(
+                  {
+                    Thing: {
+                      color: %w[blue green],
+                      shape: %w[square oval],
+                      nested_thing: [thing1.nested_thing, thing2.nested_thing] # [<Thing>, <Thing>]
+                    }
+                  }
+                )
+              end
+            end
+
+            context "with recursive flag enabled" do
+              let(:recursive) { true }
+              it "returns the mismatched attributes with the appropriate nesting" do
+                expect(thing1.inspect_mismatch(thing2, recursive:, format: :object)).to eq(
+                  {
+                    Thing: {
+                      color: %w[blue green],
+                      shape: %w[
+                        square oval
+                      ],
+                      nested_thing: {
+                        Thing: {
+                          color: %w[blue red],
+                          shape: ["oval", "another shape"],
+                          nested_thing: {
+                            Thing: {
+                              color: %w[silver blue],
+                              is_cool: [true, false]
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                )
+              end
+            end
+          end
         end
       end
     end

data/spec/spec_helper.rb

@@ -56,7 +56,7 @@ RSpec.configure do |config|
   #   # 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'
+  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:

metadata

@@ -1,31 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: mismatch-inspectable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 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.
+date: 2023-06-01 00:00:00.000000000 Z
+dependencies: []
+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: []
@@ -33,39 +21,39 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.md
+- README.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
+- lib/mismatch_inspectable/version.rb
 - spec/examples.txt
 - spec/lib/mismatch_inspectable_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/tyleCaineRhodes/mismatch-inspectable
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.2.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.4.6
 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
+test_files: []