mismatch-inspectable 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 671248717fed7d33e53f9e167f8e58d7344189fc8f2a77ab2b4fbcad603db188
-  data.tar.gz: 3c45218dd7adbbde45baddfa827ee71de4f2781d1e50aa44ce465567eca98f92
+  metadata.gz: 5d1a63392c8810b446da003f2a520b13ed9c820a9e38d825d2b1d90a9b56ac55
+  data.tar.gz: f5e50d3286ab7bcd0d75f584902272cbed5ddef4cc55b82e0709b4ab9228f25d
 SHA512:
-  metadata.gz: 365ef02e25f9e3d697d887ddab05c9fb14aeedaf9190a57d9ca2c6e197dcfeed5276c7e6d77f4282893aa5ca380035b6e967f43daf9899b451ca7ae3e8b5668c
-  data.tar.gz: eefe5088fdfc55365c237f5b5fa84472b50352b61a21f7f88302e7bf156f52f4d40b9021da44cb93d152a3918d57ecf262781b77f39c093a3d15490864dcf8a9
+  metadata.gz: 898f167833de14ad907bb1038d326b5b356fd3d7c0a7388f172f72b77f8a9aee8b084b8cf502ea42ddbb2f13a67aaa9b7b56f897eb294c7894a9d6cbc165695e
+  data.tar.gz: 550bfa28af86449bcd1931f520d99a1075cc3447baf9f00a9254e6f23113a0c5247eeaf3e6bc047c849bca35e9544e20768f084716b58f9604aa1dbc904efdd5

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

@@ -19,15 +19,16 @@ module MismatchInspectable
     end
   end
 
+  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 +40,19 @@ 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
+
   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)
 
@@ -62,18 +74,24 @@ module MismatchInspectable
       other_val,
       recursive: true,
       include_class: include_class,
-      prefix: prefix + "#{attribute}.",
+      prefix: "#{prefix}#{attribute}.",
       format: format
     )
 
-    formatter.merge_mismatches(nested_mismatches) unless nested_mismatches?(nested_mismatches)
+    formatter.merge_mismatches(nested_mismatches) unless no_nested_mismatches?(nested_mismatches)
   end
 
   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/version.rb

@@ -0,0 +1,3 @@
+module MismatchInspectable
+  VERSION = '0.1.1'
+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.00118 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:1]         | passed | 0.00041 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:2:1]       | passed | 0.0001 seconds  |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:1:1]   | passed | 0.00015 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:1:2:1] | passed | 0.00013 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:2:1]   | passed | 0.00014 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:1:2:2:1] | passed | 0.00014 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:1:3:2:1]     | passed | 0.00011 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:1:1]       | passed | 0.0001 seconds  |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:2:1]       | passed | 0.00025 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:3:1]       | passed | 0.00014 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:1:1:1] | passed | 0.00014 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:1:2:1] | passed | 0.00013 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:1:3:1] | passed | 0.00013 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:2:1:1] | passed | 0.00031 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:2:2:1] | passed | 0.0002 seconds  |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:1:2:3:1] | passed | 0.00017 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:2:1:1]   | passed | 0.00014 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:2:2:1]   | passed | 0.00012 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:2:3:1]   | passed | 0.00013 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:3:1:1]   | passed | 0.00028 seconds |
+./spec/lib/mismatch_inspectable_spec.rb[1:1:2:2:4:3:2:1]   | passed | 0.00049 seconds |

data/spec/lib/mismatch_inspectable_spec.rb

@@ -1,6 +1,6 @@
 require 'rspec'
 require 'spec_helper'
-require 'mismatch_inspectable/mismatch_inspectable'
+require 'mismatch_inspectable'
 
 class TestClass
   include MismatchInspectable
@@ -306,6 +306,104 @@ RSpec.describe MismatchInspectable do
               end
             end
           end
+
+          context 'with multiple levels of nested inspectable attributes' do
+            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
+
+            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: 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mismatch-inspectable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Tyler Rhodes
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-21 00:00:00.000000000 Z
+date: 2023-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -33,12 +33,14 @@ 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