Add diffing / deep inspection for HashWithIndifferentAccess

Author: mcmire

lib/super_diff/rails.rb

@@ -1 +1,29 @@
+module SuperDiff
+  module Rails
+    autoload :DiffFormatters, "super_diff/rails/diff_formatters"
+    autoload :Differs, "super_diff/rails/differs"
+    autoload :ObjectInspection, "super_diff/rails/object_inspection"
+    autoload :OperationalSequencers, "super_diff/rails/operational_sequencers"
+    autoload :OperationalSequences, "super_diff/rails/operational_sequences"
+  end
+end
+
+if defined?(SuperDiff::RSpec)
+  SuperDiff::RSpec.configure do |config|
+    config.add_extra_differ_class(
+      SuperDiff::Rails::Differs::HashWithIndifferentAccess,
+    )
+    config.add_extra_operational_sequencer_class(
+      SuperDiff::Rails::OperationalSequencers::HashWithIndifferentAccess,
+    )
+    config.add_extra_diff_formatter_class(
+      SuperDiff::Rails::DiffFormatters::HashWithIndifferentAccess,
+    )
+  end
+end
+
+SuperDiff::ObjectInspection.map.prepend(
+  SuperDiff::Rails::ObjectInspection::MapExtension,
+)
+
 require "super_diff/active_record"

lib/super_diff/rails/diff_formatters.rb

@@ -0,0 +1,10 @@
+module SuperDiff
+  module Rails
+    module DiffFormatters
+      autoload(
+        :HashWithIndifferentAccess,
+        "super_diff/rails/diff_formatters/hash_with_indifferent_access",
+      )
+    end
+  end
+end

lib/super_diff/rails/diff_formatters/hash_with_indifferent_access.rb

@@ -0,0 +1,36 @@
+module SuperDiff
+  module Rails
+    module DiffFormatters
+      class HashWithIndifferentAccess < SuperDiff::DiffFormatters::Base
+        def self.applies_to?(operations)
+          operations.is_a?(OperationSequences::HashWithIndifferentAccess)
+        end
+
+        def call
+          SuperDiff::DiffFormatters::Collection.call(
+            open_token: "#<HashWithIndifferentAccess {",
+            close_token: "}>",
+            collection_prefix: collection_prefix,
+            build_item_prefix: -> (operation) {
+              key =
+                if operation.respond_to?(:left_key)
+                  operation.left_key
+                else
+                  operation.key
+                end
+
+              if key.is_a?(Symbol)
+                "#{key}: "
+              else
+                "#{key.inspect} => "
+              end
+            },
+            operations: operations,
+            indent_level: indent_level,
+            add_comma: add_comma?,
+          )
+        end
+      end
+    end
+  end
+end

lib/super_diff/rails/differs.rb

@@ -0,0 +1,10 @@
+module SuperDiff
+  module Rails
+    module Differs
+      autoload(
+        :HashWithIndifferentAccess,
+        "super_diff/rails/differs/hash_with_indifferent_access",
+      )
+    end
+  end
+end

lib/super_diff/rails/differs/hash_with_indifferent_access.rb

@@ -0,0 +1,36 @@
+module SuperDiff
+  module Rails
+    module Differs
+      class HashWithIndifferentAccess < SuperDiff::Differs::Hash
+        def self.applies_to?(expected, actual)
+          (
+            expected.is_a?(::HashWithIndifferentAccess) &&
+              actual.is_a?(::Hash)
+          ) ||
+          (
+            expected.is_a?(::Hash) &&
+              actual.is_a?(::HashWithIndifferentAccess)
+          )
+        end
+
+        def call
+          DiffFormatters::HashWithIndifferentAccess.call(
+            operations,
+            indent_level: indent_level,
+          )
+        end
+
+        private
+
+        def operations
+          OperationalSequencers::HashWithIndifferentAccess.call(
+            expected: expected,
+            actual: actual,
+            extra_operational_sequencer_classes: extra_operational_sequencer_classes,
+            extra_diff_formatter_classes: extra_diff_formatter_classes,
+          )
+        end
+      end
+    end
+  end
+end

lib/super_diff/rails/object_inspection.rb

@@ -0,0 +1,8 @@
+module SuperDiff
+  module Rails
+    module ObjectInspection
+      autoload :Inspectors, "super_diff/rails/object_inspection/inspectors"
+      autoload :MapExtension, "super_diff/rails/object_inspection/map_extension"
+    end
+  end
+end

lib/super_diff/rails/object_inspection/inspectors.rb

@@ -0,0 +1,12 @@
+module SuperDiff
+  module Rails
+    module ObjectInspection
+      module Inspectors
+        autoload(
+          :HashWithIndifferentAccess,
+          "super_diff/rails/object_inspection/inspectors/hash_with_indifferent_access",
+        )
+      end
+    end
+  end
+end

lib/super_diff/rails/object_inspection/inspectors/hash_with_indifferent_access.rb

@@ -0,0 +1,18 @@
+module SuperDiff
+  module Rails
+    module ObjectInspection
+      module Inspectors
+        HashWithIndifferentAccess = SuperDiff::ObjectInspection::InspectionTree.new do
+          add_text "#<HashWithIndifferentAccess {"
+
+          nested do |hash|
+            insert_hash_inspection_of(hash)
+          end
+
+          add_break " "
+          add_text "}>"
+        end
+      end
+    end
+  end
+end

lib/super_diff/rails/object_inspection/map_extension.rb

@@ -0,0 +1,15 @@
+module SuperDiff
+  module Rails
+    module ObjectInspection
+      module MapExtension
+        def call(object)
+          if object.is_a?(::HashWithIndifferentAccess)
+            Inspectors::HashWithIndifferentAccess
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

lib/super_diff/rails/operation_sequences.rb

@@ -0,0 +1,10 @@
+module SuperDiff
+  module Rails
+    module OperationSequences
+      autoload(
+        :HashWithIndifferentAccess,
+        "super_diff/rails/operation_sequences/hash_with_indifferent_access",
+      )
+    end
+  end
+end