super_diff 0.11.0 → 0.12.1

data/lib/super_diff/active_support/operation_trees/hash_with_indifferent_access.rb

@@ -1,7 +1,7 @@
 module SuperDiff
   module ActiveSupport
     module OperationTrees
-      class HashWithIndifferentAccess < SuperDiff::OperationTrees::Base
+      class HashWithIndifferentAccess < Core::AbstractOperationTree
         protected
 
         def operation_tree_flattener_class

data/lib/super_diff/active_support.rb

@@ -1,25 +1,21 @@
+require "super_diff/active_support/differs"
+require "super_diff/active_support/inspection_tree_builders"
+require "super_diff/active_support/operation_trees"
+require "super_diff/active_support/operation_tree_builders"
+require "super_diff/active_support/operation_tree_flatteners"
+
 module SuperDiff
   module ActiveSupport
-    autoload :Differs, "super_diff/active_support/differs"
     autoload :ObjectInspection, "super_diff/active_support/object_inspection"
-    autoload(:OperationTrees, "super_diff/active_support/operation_trees")
-    autoload(
-      :OperationTreeBuilders,
-      "super_diff/active_support/operation_tree_builders"
-    )
-    autoload(
-      :OperationTreeFlatteners,
-      "super_diff/active_support/operation_tree_flatteners"
-    )
 
     SuperDiff.configure do |config|
-      config.add_extra_differ_classes(Differs::HashWithIndifferentAccess)
-      config.add_extra_operation_tree_builder_classes(
+      config.prepend_extra_differ_classes(Differs::HashWithIndifferentAccess)
+      config.prepend_extra_operation_tree_builder_classes(
         OperationTreeBuilders::HashWithIndifferentAccess
       )
-      config.add_extra_inspection_tree_builder_classes(
-        ObjectInspection::InspectionTreeBuilders::HashWithIndifferentAccess,
-        ObjectInspection::InspectionTreeBuilders::OrderedOptions
+      config.prepend_extra_inspection_tree_builder_classes(
+        InspectionTreeBuilders::HashWithIndifferentAccess,
+        InspectionTreeBuilders::OrderedOptions
       )
     end
   end

data/lib/super_diff/basic/diff_formatters/collection.rb

@@ -0,0 +1,135 @@
+module SuperDiff
+  module Basic
+    module DiffFormatters
+      # TODO: Remove
+      class Collection
+        extend AttrExtras.mixin
+
+        ICONS = { delete: "-", insert: "+" }.freeze
+        STYLES = { insert: :actual, delete: :expected, noop: :plain }.freeze
+
+        method_object(
+          %i[
+            open_token!
+            close_token!
+            operation_tree!
+            indent_level!
+            add_comma!
+            collection_prefix!
+            build_item_prefix!
+          ]
+        )
+
+        def call
+          lines.join("\n")
+        end
+
+        private
+
+        attr_query :add_comma?
+
+        def lines
+          [
+            "  #{indentation}#{collection_prefix}#{open_token}",
+            *contents,
+            "  #{indentation}#{close_token}#{comma}"
+          ]
+        end
+
+        def contents
+          operation_tree.map do |operation|
+            if operation.name == :change
+              handle_change_operation(operation)
+            else
+              handle_non_change_operation(operation)
+            end
+          end
+        end
+
+        def handle_change_operation(operation)
+          SuperDiff::RecursionGuard.guarding_recursion_of(
+            operation.left_collection,
+            operation.right_collection
+          ) do |already_seen|
+            if already_seen
+              raise "Infinite recursion!"
+            else
+              operation.child_operations.to_diff(
+                indent_level: indent_level + 1,
+                collection_prefix: build_item_prefix.call(operation),
+                add_comma: operation.should_add_comma_after_displaying?
+              )
+            end
+          end
+        end
+
+        def handle_non_change_operation(operation)
+          icon = ICONS.fetch(operation.name, " ")
+          style_name = STYLES.fetch(operation.name, :normal)
+          chunk =
+            build_chunk_for(
+              operation,
+              prefix: build_item_prefix.call(operation),
+              icon: icon
+            )
+
+          chunk << "," if operation.should_add_comma_after_displaying?
+
+          style_chunk(style_name, chunk)
+        end
+
+        def build_chunk_for(operation, prefix:, icon:)
+          if operation.value.equal?(operation.collection)
+            build_chunk_from_string(
+              SuperDiff::RecursionGuard::PLACEHOLDER,
+              prefix: build_item_prefix.call(operation),
+              icon: icon
+            )
+          else
+            build_chunk_by_inspecting(
+              operation.value,
+              prefix: build_item_prefix.call(operation),
+              icon: icon
+            )
+          end
+        end
+
+        def build_chunk_by_inspecting(value, prefix:, icon:)
+          inspection = SuperDiff.inspect_object(value, as_single_line: false)
+          build_chunk_from_string(inspection, prefix: prefix, icon: icon)
+        end
+
+        def build_chunk_from_string(value, prefix:, icon:)
+          value
+            .split("\n")
+            .map
+            .with_index do |line, index|
+              [
+                icon,
+                " ",
+                indentation(offset: 1),
+                (index == 0 ? prefix : ""),
+                line
+              ].join
+            end
+            .join("\n")
+        end
+
+        def style_chunk(style_name, chunk)
+          chunk
+            .split("\n")
+            .map { |line| Helpers.style(style_name, line) }
+            .join("\n")
+        end
+
+        def indentation(offset: 0)
+          "  " * (indent_level + offset)
+        end
+
+        def comma
+          add_comma? ? "," : ""
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/diff_formatters/multiline_string.rb

@@ -0,0 +1,34 @@
+module SuperDiff
+  module Core
+    module DiffFormatters
+      # TODO: Remove
+      class MultilineString < Base
+        def self.applies_to?(operation_tree)
+          operation_tree.is_a?(OperationTrees::MultilineString)
+        end
+
+        def call
+          lines.join("\n")
+        end
+
+        private
+
+        def lines
+          operation_tree.reduce([]) do |array, operation|
+            case operation.name
+            when :change
+              array << Helpers.style(:expected, "- #{operation.left_value}")
+              array << Helpers.style(:actual, "+ #{operation.right_value}")
+            when :delete
+              array << Helpers.style(:expected, "- #{operation.value}")
+            when :insert
+              array << Helpers.style(:actual, "+ #{operation.value}")
+            else
+              array << Helpers.style(:plain, "  #{operation.value}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/diff_formatters.rb

@@ -0,0 +1,11 @@
+module SuperDiff
+  module Basic
+    module DiffFormatters
+      autoload :Collection, "super_diff/basic/diff_formatters/collection"
+      autoload(
+        :MultilineString,
+        "super_diff/basic/diff_formatters/multiline_string"
+      )
+    end
+  end
+end

data/lib/super_diff/basic/differs/array.rb

@@ -0,0 +1,17 @@
+module SuperDiff
+  module Basic
+    module Differs
+      class Array < Core::AbstractDiffer
+        def self.applies_to?(expected, actual)
+          expected.is_a?(::Array) && actual.is_a?(::Array)
+        end
+
+        protected
+
+        def operation_tree_builder_class
+          OperationTreeBuilders::Array
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/differs/custom_object.rb

@@ -0,0 +1,19 @@
+module SuperDiff
+  module Basic
+    module Differs
+      class CustomObject < Core::AbstractDiffer
+        def self.applies_to?(expected, actual)
+          expected.class == actual.class &&
+            expected.respond_to?(:attributes_for_super_diff) &&
+            actual.respond_to?(:attributes_for_super_diff)
+        end
+
+        protected
+
+        def operation_tree_builder_class
+          OperationTreeBuilders::CustomObject
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/differs/date_like.rb

@@ -0,0 +1,17 @@
+module SuperDiff
+  module Basic
+    module Differs
+      class DateLike < Core::AbstractDiffer
+        def self.applies_to?(expected, actual)
+          SuperDiff.date_like?(expected) && SuperDiff.date_like?(actual)
+        end
+
+        protected
+
+        def operation_tree_builder_class
+          OperationTreeBuilders::DateLike
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/differs/default_object.rb

@@ -0,0 +1,24 @@
+module SuperDiff
+  module Basic
+    module Differs
+      class DefaultObject < Core::AbstractDiffer
+        def self.applies_to?(expected, actual)
+          expected.class == actual.class
+        end
+
+        protected
+
+        def operation_tree
+          SuperDiff.build_operation_tree_for(
+            expected,
+            actual,
+            extra_operation_tree_builder_classes: [
+              SuperDiff::Basic::OperationTreeBuilders::DefaultObject
+            ],
+            raise_if_nothing_applies: true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/differs/hash.rb

@@ -0,0 +1,17 @@
+module SuperDiff
+  module Basic
+    module Differs
+      class Hash < Core::AbstractDiffer
+        def self.applies_to?(expected, actual)
+          expected.is_a?(::Hash) && actual.is_a?(::Hash)
+        end
+
+        protected
+
+        def operation_tree_builder_class
+          OperationTreeBuilders::Hash
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/differs/multiline_string.rb

@@ -0,0 +1,18 @@
+module SuperDiff
+  module Basic
+    module Differs
+      class MultilineString < Core::AbstractDiffer
+        def self.applies_to?(expected, actual)
+          expected.is_a?(::String) && actual.is_a?(::String) &&
+            (expected.include?("\n") || actual.include?("\n"))
+        end
+
+        protected
+
+        def operation_tree_builder_class
+          OperationTreeBuilders::MultilineString
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/differs/time_like.rb

@@ -0,0 +1,17 @@
+module SuperDiff
+  module Basic
+    module Differs
+      class TimeLike < Core::AbstractDiffer
+        def self.applies_to?(expected, actual)
+          SuperDiff.time_like?(expected) && SuperDiff.time_like?(actual)
+        end
+
+        protected
+
+        def operation_tree_builder_class
+          OperationTreeBuilders::TimeLike
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/differs.rb

@@ -0,0 +1,24 @@
+module SuperDiff
+  module Basic
+    module Differs
+      autoload :Array, "super_diff/basic/differs/array"
+      autoload :CustomObject, "super_diff/basic/differs/custom_object"
+      autoload :DateLike, "super_diff/basic/differs/date_like"
+      autoload :DefaultObject, "super_diff/basic/differs/default_object"
+      autoload :Hash, "super_diff/basic/differs/hash"
+      autoload :MultilineString, "super_diff/basic/differs/multiline_string"
+      autoload :TimeLike, "super_diff/basic/differs/time_like"
+
+      class Main
+        def self.call(*args)
+          warn <<~EOT
+            WARNING: SuperDiff::Differs::Main.call(...) is deprecated and will be removed in the next major release.
+            Please use SuperDiff.diff(...) instead.
+            #{caller_locations.join("\n")}
+          EOT
+          SuperDiff.diff(*args)
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/{object_inspection → basic}/inspection_tree_builders/array.rb

@@ -1,13 +1,13 @@
 module SuperDiff
-  module ObjectInspection
+  module Basic
     module InspectionTreeBuilders
-      class Array < Base
+      class Array < Core::AbstractInspectionTreeBuilder
         def self.applies_to?(value)
           value.is_a?(::Array)
         end
 
         def call
-          InspectionTree.new do |t1|
+          Core::InspectionTree.new do |t1|
             t1.only_when empty do |t2|
               # stree-ignore
               t2.as_lines_when_rendering_to_lines do |t3|

data/lib/super_diff/{object_inspection → basic}/inspection_tree_builders/custom_object.rb

@@ -1,13 +1,13 @@
 module SuperDiff
-  module ObjectInspection
+  module Basic
     module InspectionTreeBuilders
-      class CustomObject < Base
+      class CustomObject < Core::AbstractInspectionTreeBuilder
         def self.applies_to?(value)
           value.respond_to?(:attributes_for_super_diff)
         end
 
         def call
-          InspectionTree.new do |t1|
+          Core::InspectionTree.new do |t1|
             t1.as_lines_when_rendering_to_lines(
               collection_bookend: :open
             ) do |t2|

data/lib/super_diff/{object_inspection → basic}/inspection_tree_builders/date_like.rb

@@ -1,13 +1,13 @@
 module SuperDiff
-  module ObjectInspection
+  module Basic
     module InspectionTreeBuilders
-      class DateLike < Base
+      class DateLike < Core::AbstractInspectionTreeBuilder
         def self.applies_to?(value)
           SuperDiff.date_like?(value)
         end
 
         def call
-          InspectionTree.new do |t1|
+          Core::InspectionTree.new do |t1|
             t1.as_lines_when_rendering_to_lines(
               collection_bookend: :open
             ) do |t2|

data/lib/super_diff/{object_inspection → basic}/inspection_tree_builders/default_object.rb

@@ -1,18 +1,17 @@
 module SuperDiff
-  module ObjectInspection
+  module Basic
     module InspectionTreeBuilders
-      class DefaultObject < Base
+      class DefaultObject < Core::AbstractInspectionTreeBuilder
         def self.applies_to?(_value)
           true
         end
 
         def call
-          InspectionTree.new do |t1|
+          Core::InspectionTree.new do |t1|
             t1.only_when empty do |t2|
               t2.as_lines_when_rendering_to_lines do |t3|
                 t3.add_text(
-                  "#<#{object.class.name}:" +
-                    SuperDiff::Helpers.object_address_for(object) + ">"
+                  "#<#{object.class.name}:" + object_address_for(object) + ">"
                 )
               end
             end
@@ -22,8 +21,7 @@ module SuperDiff
                 collection_bookend: :open
               ) do |t3|
                 t3.add_text(
-                  "#<#{object.class.name}:" +
-                    SuperDiff::Helpers.object_address_for(object)
+                  "#<#{object.class.name}:" + object_address_for(object)
                 )
 
                 # stree-ignore

data/lib/super_diff/{object_inspection → basic}/inspection_tree_builders/hash.rb

@@ -1,13 +1,13 @@
 module SuperDiff
-  module ObjectInspection
+  module Basic
     module InspectionTreeBuilders
-      class Hash < Base
+      class Hash < Core::AbstractInspectionTreeBuilder
         def self.applies_to?(value)
           value.is_a?(::Hash)
         end
 
         def call
-          InspectionTree.new do |t1|
+          Core::InspectionTree.new do |t1|
             t1.only_when empty do |t2|
               # stree-ignore
               t2.as_lines_when_rendering_to_lines do |t3|

data/lib/super_diff/{object_inspection → basic}/inspection_tree_builders/primitive.rb

@@ -1,13 +1,13 @@
 module SuperDiff
-  module ObjectInspection
+  module Basic
     module InspectionTreeBuilders
-      class Primitive < Base
+      class Primitive < Core::AbstractInspectionTreeBuilder
         def self.applies_to?(value)
           SuperDiff.primitive?(value) || value.is_a?(::String)
         end
 
         def call
-          InspectionTree.new do |t1|
+          Core::InspectionTree.new do |t1|
             t1.as_lines_when_rendering_to_lines do |t2|
               t2.add_text object.inspect
             end

data/lib/super_diff/{object_inspection → basic}/inspection_tree_builders/time_like.rb

@@ -1,13 +1,13 @@
 module SuperDiff
-  module ObjectInspection
+  module Basic
     module InspectionTreeBuilders
-      class TimeLike < Base
+      class TimeLike < Core::AbstractInspectionTreeBuilder
         def self.applies_to?(value)
           SuperDiff.time_like?(value)
         end
 
         def call
-          InspectionTree.new do |t1|
+          Core::InspectionTree.new do |t1|
             t1.as_lines_when_rendering_to_lines(
               collection_bookend: :open
             ) do |t2|

data/lib/super_diff/basic/inspection_tree_builders.rb

@@ -0,0 +1,20 @@
+module SuperDiff
+  module Basic
+    module InspectionTreeBuilders
+      autoload :Array, "super_diff/basic/inspection_tree_builders/array"
+      autoload(
+        :CustomObject,
+        "super_diff/basic/inspection_tree_builders/custom_object"
+      )
+      autoload(
+        :DefaultObject,
+        "super_diff/basic/inspection_tree_builders/default_object"
+      )
+      autoload :Hash, "super_diff/basic/inspection_tree_builders/hash"
+      autoload :Primitive, "super_diff/basic/inspection_tree_builders/primitive"
+      autoload :String, "super_diff/basic/inspection_tree_builders/string"
+      autoload :TimeLike, "super_diff/basic/inspection_tree_builders/time_like"
+      autoload :DateLike, "super_diff/basic/inspection_tree_builders/date_like"
+    end
+  end
+end

data/lib/super_diff/basic/operation_tree_builders/array.rb

@@ -0,0 +1,111 @@
+require "diff-lcs"
+
+module SuperDiff
+  module Basic
+    module OperationTreeBuilders
+      class Array < Core::AbstractOperationTreeBuilder
+        def self.applies_to?(expected, actual)
+          expected.is_a?(::Array) && actual.is_a?(::Array)
+        end
+
+        def call
+          Diff::LCS.traverse_balanced(expected, actual, lcs_callbacks)
+          operation_tree
+        end
+
+        private
+
+        def lcs_callbacks
+          @_lcs_callbacks ||=
+            LcsCallbacks.new(
+              operation_tree: operation_tree,
+              expected: expected,
+              actual: actual,
+              compare: method(:compare)
+            )
+        end
+
+        def operation_tree
+          @_operation_tree ||= OperationTrees::Array.new([])
+        end
+
+        class LcsCallbacks
+          extend AttrExtras.mixin
+
+          pattr_initialize %i[operation_tree! expected! actual! compare!]
+          public :operation_tree
+
+          def match(event)
+            add_noop_operation(event)
+          end
+
+          def discard_a(event)
+            add_delete_operation(event)
+          end
+
+          def discard_b(event)
+            add_insert_operation(event)
+          end
+
+          def change(event)
+            children = compare.(event.old_element, event.new_element)
+
+            if children
+              add_change_operation(event, children)
+            else
+              add_delete_operation(event)
+              add_insert_operation(event)
+            end
+          end
+
+          private
+
+          def add_delete_operation(event)
+            operation_tree << Core::UnaryOperation.new(
+              name: :delete,
+              collection: expected,
+              key: event.old_position,
+              value: event.old_element,
+              index: event.old_position
+            )
+          end
+
+          def add_insert_operation(event)
+            operation_tree << Core::UnaryOperation.new(
+              name: :insert,
+              collection: actual,
+              key: event.new_position,
+              value: event.new_element,
+              index: event.new_position
+            )
+          end
+
+          def add_noop_operation(event)
+            operation_tree << Core::UnaryOperation.new(
+              name: :noop,
+              collection: actual,
+              key: event.new_position,
+              value: event.new_element,
+              index: event.new_position
+            )
+          end
+
+          def add_change_operation(event, children)
+            operation_tree << Core::BinaryOperation.new(
+              name: :change,
+              left_collection: expected,
+              right_collection: actual,
+              left_key: event.old_position,
+              right_key: event.new_position,
+              left_value: event.old_element,
+              right_value: event.new_element,
+              left_index: event.old_position,
+              right_index: event.new_position,
+              children: children
+            )
+          end
+        end
+      end
+    end
+  end
+end