super_diff 0.11.0 → 0.13.0

data/spec/unit/{operation_tree_flatteners → basic/operation_tree_flatteners}/hash_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-RSpec.describe SuperDiff::OperationTreeFlatteners::Hash do
+RSpec.describe SuperDiff::Basic::OperationTreeFlatteners::Hash do
   context "given an empty tree" do
     it "returns a set of lines which are simply the open token and close token" do
       expect(described_class.call([])).to match(
@@ -30,7 +30,7 @@ RSpec.describe SuperDiff::OperationTreeFlatteners::Hash do
     it "returns a series of lines from inspecting each value, creating multiple lines upon encountering inner data structures" do
       collection = Array.new(3) { :some_value }
       operation_tree =
-        SuperDiff::OperationTrees::Hash.new(
+        SuperDiff::Basic::OperationTrees::Hash.new(
           [
             double(
               :operation,
@@ -140,7 +140,7 @@ RSpec.describe SuperDiff::OperationTreeFlatteners::Hash do
       expected = Array.new(3) { :some_value }
       actual = Array.new(4) { :some_value }
       operation_tree =
-        SuperDiff::OperationTrees::Hash.new(
+        SuperDiff::Basic::OperationTrees::Hash.new(
           [
             double(
               :operation,
@@ -280,7 +280,7 @@ RSpec.describe SuperDiff::OperationTreeFlatteners::Hash do
       collection = Array.new(3) { :some_value }
       subcollection = Array.new(2) { :some_value }
       operation_tree =
-        SuperDiff::OperationTrees::Hash.new(
+        SuperDiff::Basic::OperationTrees::Hash.new(
           [
             double(
               :operation,
@@ -300,7 +300,7 @@ RSpec.describe SuperDiff::OperationTreeFlatteners::Hash do
               right_key: :baz,
               right_index: 1,
               children:
-                SuperDiff::OperationTrees::Hash.new(
+                SuperDiff::Basic::OperationTrees::Hash.new(
                   [
                     double(
                       :operation,
@@ -429,7 +429,7 @@ RSpec.describe SuperDiff::OperationTreeFlatteners::Hash do
           .tap { |collection| collection << right_collection }
 
       operation_tree =
-        SuperDiff::OperationTrees::Hash.new(
+        SuperDiff::Basic::OperationTrees::Hash.new(
           [
             double(
               :operation,
@@ -529,7 +529,7 @@ RSpec.describe SuperDiff::OperationTreeFlatteners::Hash do
         Array.new(1) { :some_value }.tap { |coll| coll << right_subcollection }
 
       operation_tree =
-        SuperDiff::OperationTrees::Hash.new(
+        SuperDiff::Basic::OperationTrees::Hash.new(
           [
             double(
               :operation,
@@ -549,7 +549,7 @@ RSpec.describe SuperDiff::OperationTreeFlatteners::Hash do
               right_key: :baz,
               right_index: 1,
               children:
-                SuperDiff::OperationTrees::Hash.new(
+                SuperDiff::Basic::OperationTrees::Hash.new(
                   [
                     double(
                       :operation,

data/spec/unit/{operation_tree_flatteners → basic/operation_tree_flatteners}/multiline_string_spec.rb

@@ -1,9 +1,9 @@
 require "spec_helper"
 
-RSpec.describe SuperDiff::OperationTreeFlatteners::MultilineString do
+RSpec.describe SuperDiff::Basic::OperationTreeFlatteners::MultilineString do
   context "given an empty tree" do
     it "returns an empty set of lines" do
-      operation_tree = SuperDiff::OperationTrees::MultilineString.new([])
+      operation_tree = SuperDiff::Basic::OperationTrees::MultilineString.new([])
       flattened_operation_tree = described_class.call(operation_tree)
       expect(flattened_operation_tree).to eq([])
     end
@@ -13,7 +13,7 @@ RSpec.describe SuperDiff::OperationTreeFlatteners::MultilineString do
     it "returns a series of lines from printing each value" do
       collection = Array.new(3) { :some_value }
       operation_tree =
-        SuperDiff::OperationTrees::MultilineString.new(
+        SuperDiff::Basic::OperationTrees::MultilineString.new(
           [
             double(
               :operation,
@@ -73,7 +73,7 @@ RSpec.describe SuperDiff::OperationTreeFlatteners::MultilineString do
     it "returns a series of lines from printing each value" do
       collection = Array.new(3) { :some_value }
       operation_tree =
-        SuperDiff::OperationTrees::MultilineString.new(
+        SuperDiff::Basic::OperationTrees::MultilineString.new(
           [
             double(
               :operation,

data/spec/unit/core/configuration_no_rspec_spec.rb

@@ -0,0 +1,58 @@
+require "delegate"
+require "super_diff"
+
+class FakeTTYDecorator < SimpleDelegator
+  def initialize(obj, is_tty:)
+    super(obj)
+    @is_tty = is_tty
+  end
+
+  def isatty = @is_tty
+  def tty? = isatty
+end
+
+RSpec.describe SuperDiff::Core::Configuration, with_superdiff_rspec: false do
+  describe "#color_enabled?" do
+    it "is true when stdout is a TTY" do
+      original_stdout = $stdout
+      color_enabled = nil
+      begin
+        $stdout = FakeTTYDecorator.new(StringIO.new, is_tty: true)
+        color_enabled = SuperDiff.configuration.color_enabled?
+      ensure
+        $stdout = original_stdout
+      end
+      expect(color_enabled).to be(true)
+    end
+
+    it "is false when stdout is not a TTY but we are in CI" do
+      original_stdout = $stdout
+      original_ci = ENV["CI"]
+      color_enabled = nil
+      begin
+        $stdout = FakeTTYDecorator.new(StringIO.new, is_tty: false)
+        ENV["CI"] = "true"
+        color_enabled = SuperDiff.configuration.color_enabled?
+      ensure
+        $stdout = original_stdout
+        ENV["CI"] = original_ci
+      end
+      expect(color_enabled).to be(true)
+    end
+
+    it "is false when stdout is not a TTY and we are not in CI" do
+      original_stdout = $stdout
+      original_ci = ENV["CI"]
+      color_enabled = nil
+      begin
+        $stdout = FakeTTYDecorator.new(StringIO.new, is_tty: false)
+        ENV["CI"] = nil
+        color_enabled = SuperDiff.configuration.color_enabled?
+      ensure
+        $stdout = original_stdout
+        ENV["CI"] = original_ci
+      end
+      expect(color_enabled).to be(false)
+    end
+  end
+end

data/spec/unit/core/configuration_spec.rb

@@ -0,0 +1,176 @@
+require "spec_helper"
+
+RSpec.describe SuperDiff::Core::Configuration do
+  it "maintains frozen instance variables" do
+    expect(described_class.new.instance_variables).to all(be_frozen)
+  end
+
+  describe ".new" do
+    context "when passed nothing" do
+      subject(:config) { described_class.new }
+
+      it "creates a Configuration object with reasonable defaults" do
+        expect(config.actual_color).to eq(:yellow)
+      end
+    end
+
+    context "when passed options" do
+      subject(:config) { described_class.new(actual_color: :cyan) }
+
+      it "overrides the defaults with the provided options" do
+        expect(config.actual_color).to eq(:cyan)
+      end
+
+      it "uses the defaults for other options" do
+        expect(config.border_color).to eq(:blue)
+      end
+    end
+  end
+
+  describe ".dup" do
+    subject(:duplicated_config) { original_config.dup }
+
+    let(:original_config) { described_class.new(overrides) }
+    let(:in_both) { Class.new }
+    let(:in_duplicated_only) { Class.new }
+    let(:in_original_only) { Class.new }
+
+    let(:overrides) do
+      {
+        extra_diff_formatter_classes: [],
+        extra_differ_classes: [],
+        extra_inspection_tree_builder_classes: [],
+        extra_operation_tree_builder_classes: [],
+        extra_operation_tree_classes: []
+      }
+    end
+
+    %i[
+      diff_formatter
+      differ
+      operation_tree_builder
+      operation_tree
+      inspection_tree_builder
+    ].each do |object_type|
+      it "duplicates extra #{object_type.to_s.tr("_", " ")} classes" do
+        add_method_name = :"add_extra_#{object_type}_class"
+        get_method_name = :"extra_#{object_type}_classes"
+
+        original_config.send(add_method_name, in_both)
+        expect {
+          duplicated_config.send(get_method_name) << in_duplicated_only
+        }.to raise_error(FrozenError)
+        duplicated_config.send(add_method_name, in_duplicated_only)
+        original_config.send(add_method_name, in_original_only)
+
+        expect(original_config.send(get_method_name)).to include(
+          in_both,
+          in_original_only
+        )
+        expect(original_config.send(get_method_name)).not_to include(
+          in_duplicated_only
+        )
+
+        expect(duplicated_config.send(get_method_name)).to include(
+          in_both,
+          in_duplicated_only
+        )
+        expect(duplicated_config.send(get_method_name)).not_to include(
+          in_original_only
+        )
+      end
+    end
+  end
+
+  %i[
+    diff_formatter
+    differ
+    operation_tree_builder
+    operation_tree
+    inspection_tree_builder
+  ].each do |object_type|
+    describe "#add_extra_#{object_type}_classes" do
+      let(:config) { described_class.new }
+      let(:new_class1) { Class.new }
+      let(:new_class2) { Class.new }
+
+      it "appends multiple given classes" do
+        config.send("add_extra_#{object_type}_classes", new_class1, new_class2)
+        expect(config.send("extra_#{object_type}_classes")[-2..]).to eq(
+          [new_class1, new_class2]
+        )
+      end
+
+      it "appends a single given class" do
+        config.send("add_extra_#{object_type}_classes", new_class1)
+        expect(config.send("extra_#{object_type}_classes")[-1]).to eq(
+          new_class1
+        )
+      end
+    end
+
+    describe "#prepend_extra_#{object_type}_classes" do
+      let(:config) { described_class.new }
+      let(:new_class1) { Class.new }
+      let(:new_class2) { Class.new }
+
+      it "prepends multiple given classes" do
+        config.send(
+          "prepend_extra_#{object_type}_classes",
+          new_class1,
+          new_class2
+        )
+        expect(config.send("extra_#{object_type}_classes")[..1]).to eq(
+          [new_class1, new_class2]
+        )
+      end
+
+      it "prepends a single given class" do
+        config.send("prepend_extra_#{object_type}_classes", new_class1)
+        expect(config.send("extra_#{object_type}_classes")[0]).to eq(new_class1)
+      end
+    end
+  end
+
+  describe "#color_enabled?" do
+    context "when explicitly set" do
+      it "equals what was set" do
+        [true, false].each do |value|
+          SuperDiff.configuration.color_enabled.tap do |original|
+            SuperDiff.configuration.color_enabled = value
+            expect(SuperDiff.configuration.color_enabled?).to be(value)
+            SuperDiff.configuration.color_enabled = original
+          end
+        end
+      end
+    end
+
+    context "when not explicitly set" do
+      context 'when ENV["CI"] is true' do
+        it "is true" do
+          color_enabled = nil
+          ClimateControl.modify(CI: "true") do
+            color_enabled = SuperDiff.configuration.color_enabled?
+          end
+          expect(color_enabled).to be(true)
+        end
+      end
+
+      context 'when ENV["CI"] is not true' do
+        it "defaults to RSpec's config" do
+          ClimateControl.modify(CI: nil) do
+            %i[automatic on off].each do |value|
+              RSpec.configuration.color_mode.tap do |original|
+                RSpec.configuration.color_mode = value
+                expect(SuperDiff.configuration.color_enabled?).to eq(
+                  RSpec.configuration.color_enabled?
+                )
+                RSpec.configuration.color_mode = original
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/{helpers_spec.rb → core/helpers_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-RSpec.describe SuperDiff::Helpers do
+RSpec.describe SuperDiff::Core::Helpers do
   shared_examples "helper tests" do
     describe "with_slice_of_array_replaced" do
       context "if the given range covers the whole array" do
@@ -32,7 +32,7 @@ RSpec.describe SuperDiff::Helpers do
     end
 
     describe "object_address_for" do
-      if SuperDiff::Helpers.ruby_version_matches?(">= 2.7.0")
+      if SuperDiff::Core::Helpers.ruby_version_matches?(">= 2.7.0")
         it "returns an empty string for Floats" do
           expect(helper.object_address_for(1.0)).to eq("")
         end

data/spec/unit/{tiered_lines_elider_spec.rb → core/tiered_lines_elider_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-RSpec.describe SuperDiff::TieredLinesElider, type: :unit do
+RSpec.describe SuperDiff::Core::TieredLinesElider, type: :unit do
   context "and the gem is configured with :diff_elision_maximum" do
     context "and :diff_elision_maximum is more than 0" do
       context "and the line tree contains a section of noops that does not span more than the maximum" do
@@ -6299,7 +6299,7 @@ RSpec.describe SuperDiff::TieredLinesElider, type: :unit do
 
   def an_actual_line(**args)
     add_comma = args.delete(:add_comma?) { false }
-    SuperDiff::Line.new(**args, add_comma: add_comma)
+    SuperDiff::Core::Line.new(**args, add_comma: add_comma)
   end
 
   def an_expected_line(type:, indentation_level:, value:, children: [], **rest)

data/spec/unit/{tiered_lines_formatter_spec.rb → core/tiered_lines_formatter_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-RSpec.describe SuperDiff::TieredLinesFormatter, type: :unit do
+RSpec.describe SuperDiff::Core::TieredLinesFormatter, type: :unit do
   it "formats the given lines as an array of strings with appropriate colors and indentation" do
     tiered_lines = [
       line(type: :noop, indentation_level: 0, value: "["),

data/spec/unit/deprecations_spec.rb

@@ -0,0 +1,176 @@
+require "spec_helper"
+
+# stree-ignore
+common_constant_remappings = {
+  "SuperDiff::ColorizedDocumentExtensions" => "SuperDiff::Core::ColorizedDocumentExtensions",
+  "SuperDiff::Configuration" => "SuperDiff::Core::Configuration",
+  # TODO: Add back?
+  # "SuperDiff::DiffFormatters::Collection" => "SuperDiff::Basic::DiffFormatters::Collection",
+  # "SuperDiff::DiffFormatters::MultilineString" => "SuperDiff::Basic::DiffFormatters::MultilineString",
+  "SuperDiff::Differs::Array" => "SuperDiff::Basic::Differs::Array",
+  "SuperDiff::Differs::Base" => "SuperDiff::Core::AbstractDiffer",
+  "SuperDiff::Differs::CustomObject" => "SuperDiff::Basic::Differs::CustomObject",
+  "SuperDiff::Differs::DateLike" => "SuperDiff::Basic::Differs::DateLike",
+  "SuperDiff::Differs::DefaultObject" => "SuperDiff::Basic::Differs::DefaultObject",
+  "SuperDiff::Differs::Hash" => "SuperDiff::Basic::Differs::Hash",
+  "SuperDiff::Differs::MultilineString" => "SuperDiff::Basic::Differs::MultilineString",
+  "SuperDiff::Differs::TimeLike" => "SuperDiff::Basic::Differs::TimeLike",
+  "SuperDiff::Errors::NoDifferAvailableError" => "SuperDiff::Core::NoDifferAvailableError",
+  "SuperDiff::GemVersion" => "SuperDiff::Core::GemVersion",
+  "SuperDiff::Helpers" => "SuperDiff::Core::Helpers",
+  "SuperDiff::ImplementationChecks" => "SuperDiff::Core::ImplementationChecks",
+  "SuperDiff::Line" => "SuperDiff::Core::Line",
+  "SuperDiff::ObjectInspection::InspectionTree" => "SuperDiff::Core::InspectionTree",
+  "SuperDiff::ObjectInspection::InspectionTreeBuilders::Array" => "SuperDiff::Basic::InspectionTreeBuilders::Array",
+  "SuperDiff::ObjectInspection::InspectionTreeBuilders::Base" => "SuperDiff::Core::AbstractInspectionTreeBuilder",
+  "SuperDiff::ObjectInspection::InspectionTreeBuilders::CustomObject" => "SuperDiff::Basic::InspectionTreeBuilders::CustomObject",
+  "SuperDiff::ObjectInspection::InspectionTreeBuilders::DateLike" => "SuperDiff::Basic::InspectionTreeBuilders::DateLike",
+  "SuperDiff::ObjectInspection::InspectionTreeBuilders::DefaultObject" => "SuperDiff::Basic::InspectionTreeBuilders::DefaultObject",
+  "SuperDiff::ObjectInspection::InspectionTreeBuilders::Hash" => "SuperDiff::Basic::InspectionTreeBuilders::Hash",
+  "SuperDiff::ObjectInspection::InspectionTreeBuilders::Primitive" => "SuperDiff::Basic::InspectionTreeBuilders::Primitive",
+  "SuperDiff::ObjectInspection::InspectionTreeBuilders::TimeLike" => "SuperDiff::Basic::InspectionTreeBuilders::TimeLike",
+  "SuperDiff::ObjectInspection::Nodes::AsLinesWhenRenderingToLines" => "SuperDiff::Core::InspectionTreeNodes::AsLinesWhenRenderingToLines",
+  "SuperDiff::ObjectInspection::Nodes::AsPrefixWhenRenderingToLines" => "SuperDiff::Core::InspectionTreeNodes::AsPrefixWhenRenderingToLines",
+  "SuperDiff::ObjectInspection::Nodes::AsPreludeWhenRenderingToLines" => "SuperDiff::Core::InspectionTreeNodes::AsPreludeWhenRenderingToLines",
+  "SuperDiff::ObjectInspection::Nodes::AsSingleLine" => "SuperDiff::Core::InspectionTreeNodes::AsSingleLine",
+  "SuperDiff::ObjectInspection::Nodes::Base" => "SuperDiff::Core::InspectionTreeNodes::Base",
+  "SuperDiff::ObjectInspection::Nodes::Inspection" => "SuperDiff::Core::InspectionTreeNodes::Inspection",
+  "SuperDiff::ObjectInspection::Nodes::Nesting" => "SuperDiff::Core::InspectionTreeNodes::Nesting",
+  "SuperDiff::ObjectInspection::Nodes::OnlyWhen" => "SuperDiff::Core::InspectionTreeNodes::OnlyWhen",
+  "SuperDiff::ObjectInspection::Nodes::Text" => "SuperDiff::Core::InspectionTreeNodes::Text",
+  "SuperDiff::ObjectInspection::Nodes::WhenEmpty" => "SuperDiff::Core::InspectionTreeNodes::WhenEmpty",
+  "SuperDiff::ObjectInspection::Nodes::WhenNonEmpty" => "SuperDiff::Core::InspectionTreeNodes::WhenNonEmpty",
+  "SuperDiff::ObjectInspection::Nodes::WhenRenderingToLines" => "SuperDiff::Core::InspectionTreeNodes::WhenRenderingToLines",
+  "SuperDiff::ObjectInspection::Nodes::WhenRenderingToString" => "SuperDiff::Core::InspectionTreeNodes::WhenRenderingToString",
+  "SuperDiff::ObjectInspection::PrefixForNextNode" => "SuperDiff::Core::PrefixForNextInspectionTreeNode",
+  "SuperDiff::ObjectInspection::PreludeForNextNode" => "SuperDiff::Core::PreludeForNextInspectionTreeNode",
+  "SuperDiff::OperationTreeBuilders::Array" => "SuperDiff::Basic::OperationTreeBuilders::Array",
+  "SuperDiff::OperationTreeBuilders::Base" => "SuperDiff::Core::AbstractOperationTreeBuilder",
+  "SuperDiff::OperationTreeBuilders::CustomObject" => "SuperDiff::Basic::OperationTreeBuilders::CustomObject",
+  "SuperDiff::OperationTreeBuilders::DateLike" => "SuperDiff::Basic::OperationTreeBuilders::DateLike",
+  "SuperDiff::OperationTreeBuilders::DefaultObject" => "SuperDiff::Basic::OperationTreeBuilders::DefaultObject",
+  "SuperDiff::OperationTreeBuilders::Hash" => "SuperDiff::Basic::OperationTreeBuilders::Hash",
+  "SuperDiff::OperationTreeBuilders::MultilineString" => "SuperDiff::Basic::OperationTreeBuilders::MultilineString",
+  "SuperDiff::OperationTreeBuilders::TimeLike" => "SuperDiff::Basic::OperationTreeBuilders::TimeLike",
+  "SuperDiff::OperationTreeFlatteners::Array" => "SuperDiff::Basic::OperationTreeFlatteners::Array",
+  "SuperDiff::OperationTreeFlatteners::Base" => "SuperDiff::Core::AbstractOperationTreeFlattener",
+  "SuperDiff::OperationTreeFlatteners::Collection" => "SuperDiff::Basic::OperationTreeFlatteners::Collection",
+  "SuperDiff::OperationTreeFlatteners::CustomObject" => "SuperDiff::Basic::OperationTreeFlatteners::CustomObject",
+  "SuperDiff::OperationTreeFlatteners::DefaultObject" => "SuperDiff::Basic::OperationTreeFlatteners::DefaultObject",
+  "SuperDiff::OperationTreeFlatteners::Hash" => "SuperDiff::Basic::OperationTreeFlatteners::Hash",
+  "SuperDiff::OperationTreeFlatteners::MultilineString" => "SuperDiff::Basic::OperationTreeFlatteners::MultilineString",
+  "SuperDiff::OperationTrees::Array" => "SuperDiff::Basic::OperationTrees::Array",
+  "SuperDiff::OperationTrees::Base" => "SuperDiff::Core::AbstractOperationTree",
+  "SuperDiff::OperationTrees::CustomObject" => "SuperDiff::Basic::OperationTrees::CustomObject",
+  "SuperDiff::OperationTrees::DefaultObject" => "SuperDiff::Basic::OperationTrees::DefaultObject",
+  "SuperDiff::OperationTrees::Hash" => "SuperDiff::Basic::OperationTrees::Hash",
+  "SuperDiff::OperationTrees::MultilineString" => "SuperDiff::Basic::OperationTrees::MultilineString",
+  "SuperDiff::Operations::BinaryOperation" => "SuperDiff::Core::BinaryOperation",
+  "SuperDiff::Operations::UnaryOperation" => "SuperDiff::Core::UnaryOperation",
+  "SuperDiff::RSpec::ObjectInspection::InspectionTreeBuilders::CollectionContainingExactly" => "SuperDiff::RSpec::InspectionTreeBuilders::CollectionContainingExactly",
+  "SuperDiff::RSpec::ObjectInspection::InspectionTreeBuilders::CollectionIncluding" => "SuperDiff::RSpec::InspectionTreeBuilders::CollectionIncluding",
+  "SuperDiff::RSpec::ObjectInspection::InspectionTreeBuilders::Double" => "SuperDiff::RSpec::InspectionTreeBuilders::Double",
+  "SuperDiff::RSpec::ObjectInspection::InspectionTreeBuilders::GenericDescribableMatcher" => "SuperDiff::RSpec::InspectionTreeBuilders::GenericDescribableMatcher",
+  "SuperDiff::RSpec::ObjectInspection::InspectionTreeBuilders::HashIncluding" => "SuperDiff::RSpec::InspectionTreeBuilders::HashIncluding",
+  "SuperDiff::RSpec::ObjectInspection::InspectionTreeBuilders::InstanceOf" => "SuperDiff::RSpec::InspectionTreeBuilders::InstanceOf",
+  "SuperDiff::RSpec::ObjectInspection::InspectionTreeBuilders::KindOf" => "SuperDiff::RSpec::InspectionTreeBuilders::KindOf",
+  "SuperDiff::RSpec::ObjectInspection::InspectionTreeBuilders::ObjectHavingAttributes" => "SuperDiff::RSpec::InspectionTreeBuilders::ObjectHavingAttributes",
+  "SuperDiff::RSpec::ObjectInspection::InspectionTreeBuilders::Primitive" => "SuperDiff::RSpec::InspectionTreeBuilders::Primitive",
+  "SuperDiff::RSpec::ObjectInspection::InspectionTreeBuilders::ValueWithin" => "SuperDiff::RSpec::InspectionTreeBuilders::ValueWithin",
+  "SuperDiff::RecursionGuard" => "SuperDiff::Core::RecursionGuard",
+  "SuperDiff::TieredLines" => "SuperDiff::Core::TieredLines",
+  "SuperDiff::TieredLinesElider" => "SuperDiff::Core::TieredLinesElider",
+  "SuperDiff::TieredLinesFormatter" => "SuperDiff::Core::TieredLinesFormatter",
+}
+
+# stree-ignore
+active_record_constant_remappings = {
+  "SuperDiff::ActiveRecord::ObjectInspection::InspectionTreeBuilders::ActiveRecordModel" => "SuperDiff::ActiveRecord::InspectionTreeBuilders::ActiveRecordModel",
+  "SuperDiff::ActiveRecord::ObjectInspection::InspectionTreeBuilders::ActiveRecordRelation" => "SuperDiff::ActiveRecord::InspectionTreeBuilders::ActiveRecordRelation",
+}
+
+# stree-ignore
+active_support_constant_remappings = {
+  "SuperDiff::ActiveSupport::ObjectInspection::InspectionTreeBuilders::HashWithIndifferentAccess" => "SuperDiff::ActiveSupport::InspectionTreeBuilders::HashWithIndifferentAccess",
+  "SuperDiff::ActiveSupport::ObjectInspection::InspectionTreeBuilders::OrderedOptions" => "SuperDiff::ActiveSupport::InspectionTreeBuilders::OrderedOptions",
+}
+
+common_constant_remappings.each do |old_constant_name, new_constant_name|
+  RSpec.describe old_constant_name, type: :unit do
+    it "maps to #{new_constant_name}" do
+      capture_warnings do
+        expect(Object.const_get(old_constant_name)).to be(
+          Object.const_get(new_constant_name)
+        )
+      end
+    end
+
+    it "points users to #{new_constant_name} instead" do
+      expect(old_constant_name).to be_deprecated_in_favor_of(new_constant_name)
+    end
+  end
+end
+
+active_record_constant_remappings.each do |old_constant_name, new_constant_name|
+  RSpec.describe old_constant_name, type: :unit, active_record: true do
+    it "maps to #{new_constant_name}" do
+      capture_warnings do
+        expect(Object.const_get(old_constant_name)).to be(
+          Object.const_get(new_constant_name)
+        )
+      end
+    end
+
+    it "points users to #{new_constant_name} instead" do
+      expect(old_constant_name).to be_deprecated_in_favor_of(new_constant_name)
+    end
+  end
+end
+
+active_support_constant_remappings.each do |old_constant_name, new_constant_name|
+  RSpec.describe old_constant_name, type: :unit, active_support: true do
+    it "maps to #{new_constant_name}" do
+      capture_warnings do
+        expect(Object.const_get(old_constant_name)).to be(
+          Object.const_get(new_constant_name)
+        )
+      end
+    end
+
+    it "points users to #{new_constant_name} instead" do
+      expect(old_constant_name).to be_deprecated_in_favor_of(new_constant_name)
+    end
+  end
+end
+
+RSpec.describe "SuperDiff::Differs::Main.call", type: :unit do
+  it "maps to SuperDiff.diff" do
+    capture_warnings do
+      diff_before = SuperDiff::Differs::Main.call(1, 2)
+      diff_after = SuperDiff.diff(1, 2)
+      expect(diff_before).to eq(diff_after)
+    end
+  end
+end
+
+RSpec.describe "SuperDiff::OperationTreeBuilders::Main.call", type: :unit do
+  it "maps to SuperDiff.build_operation_tree_for" do
+    capture_warnings do
+      operation_tree_builder_before =
+        SuperDiff::OperationTreeBuilders::Main.call(1, 2)
+      operation_tree_builder_after = SuperDiff.build_operation_tree_for(1, 2)
+      expect(operation_tree_builder_before).to eq(operation_tree_builder_after)
+    end
+  end
+end
+
+RSpec.describe "SuperDiff::OperationTrees::Main.call", type: :unit do
+  it "maps to SuperDiff.find_operation_tree_for" do
+    capture_warnings do
+      operation_tree_before =
+        SuperDiff::OperationTrees::Main.call(%i[foo bar baz])
+      operation_tree_after = SuperDiff.find_operation_tree_for(%i[foo bar baz])
+      expect(operation_tree_before).to eq(operation_tree_after)
+    end
+  end
+end

data/spec/unit/equality_matchers/main_spec.rb

@@ -1598,8 +1598,8 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
           #{
           colored do
-            expected_line %(Expected: #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(expected)} @character="mirage", @handle="martymcfly", @health=0.3, @inventory=["flatline", "purple body shield"], @shields=0.6, @ultimate=0.8>)
-            actual_line %(  Actual: #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(actual)} @character="lifeline", @handle="docbrown", @health=0.3, @inventory=["wingman", "mastiff"], @shields=0.6, @ultimate=0.8>)
+            expected_line %(Expected: #<SuperDiff::Test::Player:#{SuperDiff::Core::Helpers.object_address_for(expected)} @character="mirage", @handle="martymcfly", @health=0.3, @inventory=["flatline", "purple body shield"], @shields=0.6, @ultimate=0.8>)
+            actual_line %(  Actual: #<SuperDiff::Test::Player:#{SuperDiff::Core::Helpers.object_address_for(actual)} @character="lifeline", @handle="docbrown", @health=0.3, @inventory=["wingman", "mastiff"], @shields=0.6, @ultimate=0.8>)
           end
         }
 
@@ -1607,7 +1607,7 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
           #{
           colored do
-            plain_line %(  #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(actual)} {)
+            plain_line %(  #<SuperDiff::Test::Player:#{SuperDiff::Core::Helpers.object_address_for(actual)} {)
             expected_line %(-   @character="mirage",)
             actual_line %(+   @character="lifeline",)
             expected_line %(-   @handle="martymcfly",)
@@ -1677,8 +1677,8 @@ RSpec.describe SuperDiff::EqualityMatchers::Main, type: :unit do
 
           #{
           colored do
-            expected_line %(Expected: #<SuperDiff::Test::Item:#{SuperDiff::Helpers.object_address_for(expected)} @name="camera", @quantity=3>)
-            actual_line %(  Actual: #<SuperDiff::Test::Player:#{SuperDiff::Helpers.object_address_for(actual)} @character="Jon", @handle="mcmire", @health=4, @inventory=["sword"], @shields=11.4, @ultimate=true>)
+            expected_line %(Expected: #<SuperDiff::Test::Item:#{SuperDiff::Core::Helpers.object_address_for(expected)} @name="camera", @quantity=3>)
+            actual_line %(  Actual: #<SuperDiff::Test::Player:#{SuperDiff::Core::Helpers.object_address_for(actual)} @character="Jon", @handle="mcmire", @health=4, @inventory=["sword"], @shields=11.4, @ultimate=true>)
           end
         }
         STR

data/super_diff.gemspec

@@ -3,9 +3,9 @@ require File.expand_path("lib/super_diff/version", __dir__)
 Gem::Specification.new do |s|
   s.name = "super_diff"
   s.version = SuperDiff::VERSION
-  s.authors = ["Elliot Winkler"]
-  s.email = ["elliot.winkler@gmail.com"]
-  s.homepage = "https://github.com/mcmire/super_diff"
+  s.authors = ["Elliot Winkler", "Splitwise, Inc."]
+  s.email = ["oss-community@splitwise.com"]
+  s.homepage = "https://github.com/splitwise/super_diff"
   s.summary =
     "A better way to view differences between complex data structures in RSpec."
   s.license = "MIT"
@@ -13,6 +13,13 @@ Gem::Specification.new do |s|
     SuperDiff is a gem that hooks into RSpec to intelligently display the
     differences between two data structures of any type.
   DESC
+  s.metadata = {
+    "bug_tracker_uri" => "https://github.com/splitwise/super_diff/issues",
+    "changelog_uri" =>
+      "https://github.com/splitwise/super_diff/blob/main/CHANGELOG.md",
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => "https://github.com/splitwise/super_diff"
+  }
   s.required_ruby_version = ">= 3"
 
   s.files = %w[README.md super_diff.gemspec] + Dir["lib/**/*"]