super_diff 0.11.0 → 0.12.1

data/lib/super_diff/rspec/inspection_tree_builders/hash_including.rb

@@ -0,0 +1,40 @@
+module SuperDiff
+  module RSpec
+    module InspectionTreeBuilders
+      class HashIncluding < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(value)
+          SuperDiff::RSpec.a_hash_including_something?(value) ||
+            SuperDiff::RSpec.hash_including_something?(value)
+        end
+
+        def call
+          Core::InspectionTree.new do |t1|
+            # stree-ignore
+            t1.as_lines_when_rendering_to_lines(
+                collection_bookend: :open
+              ) do |t2|
+                t2.add_text "#<a hash including ("
+              end
+
+            t1.nested do |t2|
+              if SuperDiff::RSpec.a_hash_including_something?(object)
+                t2.insert_hash_inspection_of(object.expecteds.first)
+              else
+                t2.insert_hash_inspection_of(
+                  object.instance_variable_get(:@expected)
+                )
+              end
+            end
+
+            # stree-ignore
+            t1.as_lines_when_rendering_to_lines(
+                collection_bookend: :close
+              ) do |t2|
+                t2.add_text ")>"
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/inspection_tree_builders/instance_of.rb

@@ -0,0 +1,25 @@
+module SuperDiff
+  module RSpec
+    module InspectionTreeBuilders
+      class InstanceOf < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(value)
+          SuperDiff::RSpec.an_instance_of_something?(value) ||
+            SuperDiff::RSpec.instance_of_something?(value)
+        end
+
+        def call
+          Core::InspectionTree.new do |t1|
+            klass =
+              if SuperDiff::RSpec.an_instance_of_something?(object)
+                object.expected
+              else
+                object.instance_variable_get(:@klass)
+              end
+
+            t1.add_text "#<an instance of #{klass}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/inspection_tree_builders/kind_of.rb

@@ -0,0 +1,25 @@
+module SuperDiff
+  module RSpec
+    module InspectionTreeBuilders
+      class KindOf < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(value)
+          SuperDiff::RSpec.a_kind_of_something?(value) ||
+            SuperDiff::RSpec.kind_of_something?(value)
+        end
+
+        def call
+          Core::InspectionTree.new do |t1|
+            klass =
+              if SuperDiff::RSpec.a_kind_of_something?(object)
+                object.expected
+              else
+                object.instance_variable_get(:@klass)
+              end
+
+            t1.add_text "#<a kind of #{klass}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/inspection_tree_builders/object_having_attributes.rb

@@ -0,0 +1,34 @@
+module SuperDiff
+  module RSpec
+    module InspectionTreeBuilders
+      class ObjectHavingAttributes < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(value)
+          SuperDiff::RSpec.an_object_having_some_attributes?(value)
+        end
+
+        def call
+          Core::InspectionTree.new do |t1|
+            # stree-ignore
+            t1.as_lines_when_rendering_to_lines(
+                collection_bookend: :open
+              ) do |t2|
+                t2.add_text "#<an object having attributes ("
+              end
+
+            # stree-ignore
+            t1.nested do |t2|
+                t2.insert_hash_inspection_of(object.expected)
+              end
+
+            # stree-ignore
+            t1.as_lines_when_rendering_to_lines(
+                collection_bookend: :close
+              ) do |t2|
+                t2.add_text ")>"
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/inspection_tree_builders/primitive.rb

@@ -0,0 +1,9 @@
+module SuperDiff
+  module RSpec
+    module InspectionTreeBuilders
+      # TODO: Is this needed?
+      class Primitive < Basic::InspectionTreeBuilders::Primitive
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/inspection_tree_builders/value_within.rb

@@ -0,0 +1,30 @@
+module SuperDiff
+  module RSpec
+    module InspectionTreeBuilders
+      class ValueWithin < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(value)
+          SuperDiff::RSpec.a_value_within_something?(value)
+        end
+
+        def call
+          Core::InspectionTree.new do |t1|
+            t1.as_prelude_when_rendering_to_lines do |t2|
+              t2.add_text "#<a value within "
+
+              t2.add_inspection_of(
+                object.base_matcher.instance_variable_get("@delta"),
+                as_lines: false
+              )
+
+              t2.add_text " of "
+            end
+
+            t1.add_inspection_of object.expected
+
+            t1.add_text ">"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/inspection_tree_builders.rb

@@ -0,0 +1,40 @@
+module SuperDiff
+  module RSpec
+    module InspectionTreeBuilders
+      autoload(
+        :CollectionContainingExactly,
+        "super_diff/rspec/inspection_tree_builders/collection_containing_exactly"
+      )
+      autoload(
+        :CollectionIncluding,
+        "super_diff/rspec/inspection_tree_builders/collection_including"
+      )
+      autoload :Double, "super_diff/rspec/inspection_tree_builders/double"
+      autoload(
+        :GenericDescribableMatcher,
+        "super_diff/rspec/inspection_tree_builders/generic_describable_matcher"
+      )
+      autoload(
+        :HashIncluding,
+        "super_diff/rspec/inspection_tree_builders/hash_including"
+      )
+      autoload(
+        :InstanceOf,
+        "super_diff/rspec/inspection_tree_builders/instance_of"
+      )
+      autoload :KindOf, "super_diff/rspec/inspection_tree_builders/kind_of"
+      autoload(
+        :ObjectHavingAttributes,
+        "super_diff/rspec/inspection_tree_builders/object_having_attributes"
+      )
+      autoload(
+        :Primitive,
+        "super_diff/rspec/inspection_tree_builders/primitive"
+      )
+      autoload(
+        :ValueWithin,
+        "super_diff/rspec/inspection_tree_builders/value_within"
+      )
+    end
+  end
+end

data/lib/super_diff/rspec/object_inspection.rb

@@ -1,10 +1,20 @@
 module SuperDiff
   module RSpec
     module ObjectInspection
-      autoload(
-        :InspectionTreeBuilders,
-        "super_diff/rspec/object_inspection/inspection_tree_builders"
-      )
+      module InspectionTreeBuilders
+        def self.const_missing(missing_const_name)
+          if RSpec::InspectionTreeBuilders.const_defined?(missing_const_name)
+            warn <<~EOT
+          WARNING: SuperDiff::RSpec::ObjectInspection::InspectionTreeBuilders::#{missing_const_name} is deprecated and will be removed in the next major release.
+          Please use SuperDiff::RSpec::InspectionTreeBuilders::#{missing_const_name} instead.
+          #{caller_locations.join("\n")}
+        EOT
+            RSpec::InspectionTreeBuilders.const_get(missing_const_name)
+          else
+            super
+          end
+        end
+      end
     end
   end
 end

data/lib/super_diff/rspec/operation_tree_builders/collection_containing_exactly.rb

@@ -1,7 +1,7 @@
 module SuperDiff
   module RSpec
     module OperationTreeBuilders
-      class CollectionContainingExactly < SuperDiff::OperationTreeBuilders::Base
+      class CollectionContainingExactly < Core::AbstractOperationTreeBuilder
         def self.applies_to?(expected, actual)
           SuperDiff::RSpec.a_collection_containing_exactly_something?(
             expected
@@ -47,7 +47,7 @@ module SuperDiff
 
         def add_noop_to(operations, index)
           value = actual[index]
-          operations << ::SuperDiff::Operations::UnaryOperation.new(
+          operations << Core::UnaryOperation.new(
             name: :noop,
             collection: collection,
             key: index,
@@ -58,7 +58,7 @@ module SuperDiff
 
         def add_delete_to(operations, index)
           value = expected.expected[index]
-          operations << ::SuperDiff::Operations::UnaryOperation.new(
+          operations << Core::UnaryOperation.new(
             name: :delete,
             collection: collection,
             key: index,
@@ -69,7 +69,7 @@ module SuperDiff
 
         def add_insert_to(operations, index)
           value = actual[index]
-          operations << ::SuperDiff::Operations::UnaryOperation.new(
+          operations << Core::UnaryOperation.new(
             name: :insert,
             collection: collection,
             key: index,

data/lib/super_diff/rspec/operation_tree_builders/collection_including.rb

@@ -1,7 +1,7 @@
 module SuperDiff
   module RSpec
     module OperationTreeBuilders
-      class CollectionIncluding < SuperDiff::OperationTreeBuilders::Array
+      class CollectionIncluding < Basic::OperationTreeBuilders::Array
         def self.applies_to?(expected, actual)
           (
             SuperDiff::RSpec.a_collection_including_something?(expected) ||

data/lib/super_diff/rspec/operation_tree_builders/hash_including.rb

@@ -1,7 +1,7 @@
 module SuperDiff
   module RSpec
     module OperationTreeBuilders
-      class HashIncluding < SuperDiff::OperationTreeBuilders::Hash
+      class HashIncluding < Basic::OperationTreeBuilders::Hash
         include ::RSpec::Matchers::Composable
 
         def self.applies_to?(expected, actual)

data/lib/super_diff/rspec/operation_tree_builders/object_having_attributes.rb

@@ -1,7 +1,7 @@
 module SuperDiff
   module RSpec
     module OperationTreeBuilders
-      class ObjectHavingAttributes < SuperDiff::OperationTreeBuilders::DefaultObject
+      class ObjectHavingAttributes < Basic::OperationTreeBuilders::DefaultObject
         def self.applies_to?(expected, _actual)
           SuperDiff::RSpec.an_object_having_some_attributes?(expected)
         end
@@ -9,7 +9,7 @@ module SuperDiff
         protected
 
         def build_operation_tree
-          find_operation_tree_for(actual)
+          SuperDiff.find_operation_tree_for(actual)
         end
 
         def attribute_names

data/lib/super_diff/rspec.rb

@@ -1,15 +1,17 @@
 require "super_diff"
 
+require "super_diff/rspec/differs"
+require "super_diff/rspec/inspection_tree_builders"
+require "super_diff/rspec/operation_tree_builders"
+
 module SuperDiff
   module RSpec
     autoload :AugmentedMatcher, "super_diff/rspec/augmented_matcher"
     autoload :Configuration, "super_diff/rspec/configuration"
     autoload :Differ, "super_diff/rspec/differ"
-    autoload :Differs, "super_diff/rspec/differs"
     autoload :MatcherTextBuilders, "super_diff/rspec/matcher_text_builders"
     autoload :MatcherTextTemplate, "super_diff/rspec/matcher_text_template"
     autoload :ObjectInspection, "super_diff/rspec/object_inspection"
-    autoload :OperationTreeBuilders, "super_diff/rspec/operation_tree_builders"
 
     def self.configure(&block)
       SuperDiff.configure(&block)
@@ -84,37 +86,37 @@ module SuperDiff
       @_rspec_version ||=
         begin
           require "rspec/core/version"
-          GemVersion.new(::RSpec::Core::Version::STRING)
+          Core::GemVersion.new(::RSpec::Core::Version::STRING)
         end
     end
 
     SuperDiff.configuration.tap do |config|
-      config.add_extra_differ_classes(
+      config.prepend_extra_differ_classes(
         Differs::CollectionContainingExactly,
         Differs::CollectionIncluding,
         Differs::HashIncluding,
         Differs::ObjectHavingAttributes
       )
 
-      config.add_extra_operation_tree_builder_classes(
+      config.prepend_extra_inspection_tree_builder_classes(
+        InspectionTreeBuilders::Double,
+        InspectionTreeBuilders::CollectionContainingExactly,
+        InspectionTreeBuilders::CollectionIncluding,
+        InspectionTreeBuilders::HashIncluding,
+        InspectionTreeBuilders::InstanceOf,
+        InspectionTreeBuilders::KindOf,
+        InspectionTreeBuilders::ObjectHavingAttributes,
+        # ObjectInspection::InspectionTreeBuilders::Primitive,
+        InspectionTreeBuilders::ValueWithin,
+        InspectionTreeBuilders::GenericDescribableMatcher
+      )
+
+      config.prepend_extra_operation_tree_builder_classes(
         OperationTreeBuilders::CollectionContainingExactly,
         OperationTreeBuilders::CollectionIncluding,
         OperationTreeBuilders::HashIncluding,
         OperationTreeBuilders::ObjectHavingAttributes
       )
-
-      config.add_extra_inspection_tree_builder_classes(
-        ObjectInspection::InspectionTreeBuilders::Double,
-        ObjectInspection::InspectionTreeBuilders::CollectionContainingExactly,
-        ObjectInspection::InspectionTreeBuilders::CollectionIncluding,
-        ObjectInspection::InspectionTreeBuilders::HashIncluding,
-        ObjectInspection::InspectionTreeBuilders::InstanceOf,
-        ObjectInspection::InspectionTreeBuilders::KindOf,
-        ObjectInspection::InspectionTreeBuilders::ObjectHavingAttributes,
-        # ObjectInspection::InspectionTreeBuilders::Primitive,
-        ObjectInspection::InspectionTreeBuilders::ValueWithin,
-        ObjectInspection::InspectionTreeBuilders::GenericDescribableMatcher
-      )
     end
   end
 end

data/lib/super_diff/version.rb

@@ -1,3 +1,3 @@
 module SuperDiff
-  VERSION = "0.11.0".freeze
+  VERSION = "0.12.1".freeze
 end

data/lib/super_diff.rb

@@ -1,47 +1,93 @@
 require "attr_extras/explicit"
-require "diff-lcs"
-require "patience_diff"
 require "date"
 
 module SuperDiff
-  autoload(
-    :ColorizedDocumentExtensions,
-    "super_diff/colorized_document_extensions"
-  )
-  autoload :OperationTreeFlatteners, "super_diff/operation_tree_flatteners"
-  autoload :Configuration, "super_diff/configuration"
+  autoload :Core, "super_diff/core"
   autoload :Csi, "super_diff/csi"
-  autoload :DiffFormatters, "super_diff/diff_formatters"
   autoload :Differs, "super_diff/differs"
   autoload :EqualityMatchers, "super_diff/equality_matchers"
   autoload :Errors, "super_diff/errors"
-  autoload :GemVersion, "super_diff/gem_version"
-  autoload :Helpers, "super_diff/helpers"
-  autoload :ImplementationChecks, "super_diff/implementation_checks"
-  autoload :Line, "super_diff/line"
-  autoload :TieredLines, "super_diff/tiered_lines"
-  autoload :TieredLinesElider, "super_diff/tiered_lines_elider"
-  autoload :TieredLinesFormatter, "super_diff/tiered_lines_formatter"
   autoload :ObjectInspection, "super_diff/object_inspection"
-  autoload :OperationTrees, "super_diff/operation_trees"
   autoload :OperationTreeBuilders, "super_diff/operation_tree_builders"
+  autoload :OperationTreeFlatteners, "super_diff/operation_tree_flatteners"
+  autoload :OperationTrees, "super_diff/operation_trees"
   autoload :Operations, "super_diff/operations"
-  autoload :RecursionGuard, "super_diff/recursion_guard"
   autoload :VERSION, "super_diff/version"
 
+  def self.const_missing(missing_const_name)
+    if Core.const_defined?(missing_const_name)
+      warn <<~EOT
+        WARNING: SuperDiff::#{missing_const_name} is deprecated and will be removed in the next major release.
+        Please use SuperDiff::Core::#{missing_const_name} instead.
+        #{caller_locations.join("\n")}
+      EOT
+      Core.const_get(missing_const_name)
+    elsif Basic.const_defined?(missing_const_name)
+      warn <<~EOT
+        WARNING: SuperDiff::#{missing_const_name} is deprecated and will be removed in the next major release.
+        Please use SuperDiff::Basic::#{missing_const_name} instead.
+        #{caller_locations.join("\n")}
+      EOT
+      Basic.const_get(missing_const_name)
+    else
+      super
+    end
+  end
+
   def self.configure
     yield configuration
     configuration.updated
   end
 
   def self.configuration
-    @_configuration ||= Configuration.new
+    @_configuration ||= Core::Configuration.new
+  end
+
+  def self.diff(
+    expected,
+    actual,
+    indent_level: 0,
+    raise_if_nothing_applies: true
+  )
+    Core::DifferDispatcher.call(
+      expected,
+      actual,
+      available_classes: configuration.extra_differ_classes,
+      indent_level: indent_level,
+      raise_if_nothing_applies: raise_if_nothing_applies
+    )
+  end
+
+  def self.build_operation_tree_for(
+    expected,
+    actual,
+    extra_operation_tree_builder_classes: [],
+    raise_if_nothing_applies: false
+  )
+    Core::OperationTreeBuilderDispatcher.call(
+      expected,
+      actual,
+      available_classes:
+        configuration.extra_operation_tree_builder_classes +
+          extra_operation_tree_builder_classes,
+      raise_if_nothing_applies: raise_if_nothing_applies
+    )
+  end
+
+  def self.find_operation_tree_for(value)
+    SuperDiff::Core::OperationTreeFinder.call(
+      value,
+      available_classes: configuration.extra_operation_tree_classes
+    )
   end
 
   def self.inspect_object(object, as_lines:, **rest)
-    SuperDiff::RecursionGuard.guarding_recursion_of(object) do
+    Core::RecursionGuard.guarding_recursion_of(object) do
       inspection_tree =
-        ObjectInspection::InspectionTreeBuilders::Main.call(object)
+        Core::InspectionTreeBuilderDispatcher.call(
+          object,
+          available_classes: configuration.extra_inspection_tree_builder_classes
+        )
 
       if as_lines
         inspection_tree.render_to_lines(object, **rest)
@@ -87,3 +133,5 @@ module SuperDiff
     end
   end
 end
+
+require "super_diff/basic"