super_diff 0.10.0 → 0.12.0

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

@@ -0,0 +1,26 @@
+module SuperDiff
+  module Basic
+    module OperationTreeBuilders
+      class TimeLike < CustomObject
+        def self.applies_to?(expected, actual)
+          SuperDiff.time_like?(expected) && SuperDiff.time_like?(actual)
+        end
+
+        protected
+
+        def attribute_names
+          base = %w[year month day hour min sec subsec zone utc_offset]
+
+          # If timezones are different, also show a normalized timestamp at the
+          # end of the diff to help visualize why they are different moments in
+          # time.
+          if actual.zone != expected.zone
+            base + ["utc"]
+          else
+            base
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/operation_tree_builders.rb

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

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

@@ -0,0 +1,17 @@
+module SuperDiff
+  module Basic
+    module OperationTreeFlatteners
+      class Array < Collection
+        protected
+
+        def open_token
+          "["
+        end
+
+        def close_token
+          "]"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+module SuperDiff
+  module Basic
+    module OperationTreeFlatteners
+      class Collection < Core::AbstractOperationTreeFlattener
+        protected
+
+        def build_tiered_lines
+          [
+            Core::Line.new(
+              type: :noop,
+              indentation_level: indentation_level,
+              value: open_token,
+              collection_bookend: :open
+            ),
+            *inner_lines,
+            Core::Line.new(
+              type: :noop,
+              indentation_level: indentation_level,
+              value: close_token,
+              collection_bookend: :close
+            )
+          ]
+        end
+
+        def inner_lines
+          @_inner_lines ||=
+            operation_tree.flat_map do |operation|
+              lines =
+                if operation.name == :change
+                  build_lines_for_change_operation(operation)
+                else
+                  build_lines_for_non_change_operation(operation)
+                end
+
+              maybe_add_prefix_at_beginning_of_lines(
+                maybe_add_comma_at_end_of_lines(lines, operation),
+                operation
+              )
+            end
+        end
+
+        def maybe_add_prefix_at_beginning_of_lines(lines, operation)
+          if add_prefix_at_beginning_of_lines?(operation)
+            add_prefix_at_beginning_of_lines(lines, operation)
+          else
+            lines
+          end
+        end
+
+        def add_prefix_at_beginning_of_lines?(operation)
+          !!item_prefix_for(operation)
+        end
+
+        def add_prefix_at_beginning_of_lines(lines, operation)
+          [lines[0].prefixed_with(item_prefix_for(operation))] + lines[1..-1]
+        end
+
+        def maybe_add_comma_at_end_of_lines(lines, operation)
+          if last_item_in_collection?(operation)
+            lines
+          else
+            add_comma_at_end_of_lines(lines)
+          end
+        end
+
+        def last_item_in_collection?(operation)
+          if operation.name == :change
+            operation.left_index == operation.left_collection.size - 1 &&
+              operation.right_index == operation.right_collection.size - 1
+          else
+            operation.index == operation.collection.size - 1
+          end
+        end
+
+        def add_comma_at_end_of_lines(lines)
+          lines[0..-2] + [lines[-1].with_comma]
+        end
+
+        def build_lines_for_change_operation(operation)
+          Core::RecursionGuard.guarding_recursion_of(
+            operation.left_collection,
+            operation.right_collection
+          ) do |already_seen|
+            if already_seen
+              raise InfiniteRecursionError
+            else
+              operation.children.flatten(
+                indentation_level: indentation_level + 1
+              )
+            end
+          end
+        end
+
+        def build_lines_for_non_change_operation(operation)
+          indentation_level = @indentation_level + 1
+
+          if recursive_operation?(operation)
+            [
+              Core::Line.new(
+                type: operation.name,
+                indentation_level: indentation_level,
+                value: Core::RecursionGuard::PLACEHOLDER
+              )
+            ]
+          else
+            build_lines_from_inspection_of(
+              operation.value,
+              type: operation.name,
+              indentation_level: indentation_level
+            )
+          end
+        end
+
+        def recursive_operation?(operation)
+          operation.value.equal?(operation.collection) ||
+            Core::RecursionGuard.already_seen?(operation.value)
+        end
+
+        def item_prefix_for(_operation)
+          ""
+        end
+
+        def build_lines_from_inspection_of(value, type:, indentation_level:)
+          SuperDiff.inspect_object(
+            value,
+            as_lines: true,
+            type: type,
+            indentation_level: indentation_level
+          )
+        end
+
+        class InfiniteRecursionError < StandardError
+          def initialize(_message = nil)
+            super("Unhandled recursive data structure encountered!")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module SuperDiff
+  module Basic
+    module OperationTreeFlatteners
+      class CustomObject < Collection
+        protected
+
+        def open_token
+          "#<%<class>s {" % { class: operation_tree.underlying_object.class }
+        end
+
+        def close_token
+          "}>"
+        end
+
+        def item_prefix_for(operation)
+          key =
+            # Note: We could have used the right_key here too, they're both the
+            # same keys
+            if operation.respond_to?(:left_key)
+              operation.left_key
+            else
+              operation.key
+            end
+
+          "#{key}: "
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module SuperDiff
+  module Basic
+    module OperationTreeFlatteners
+      class DefaultObject < Collection
+        protected
+
+        def open_token
+          "#<#{operation_tree.underlying_object.class.name}:" +
+            Core::Helpers.object_address_for(operation_tree.underlying_object) +
+            " {"
+        end
+
+        def close_token
+          "}>"
+        end
+
+        def item_prefix_for(operation)
+          key =
+            # Note: We could have used the right_key here too, they're both the
+            # same keys
+            if operation.respond_to?(:left_key)
+              operation.left_key
+            else
+              operation.key
+            end
+
+          "@#{key}="
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module SuperDiff
+  module Basic
+    module OperationTreeFlatteners
+      class Hash < Collection
+        protected
+
+        def open_token
+          "{"
+        end
+
+        def close_token
+          "}"
+        end
+
+        def item_prefix_for(operation)
+          key = key_for(operation)
+
+          format_keys_as_kwargs? ? "#{key}: " : "#{key.inspect} => "
+        end
+
+        private
+
+        def format_keys_as_kwargs?
+          operation_tree.all? { |operation| key_for(operation).is_a?(Symbol) }
+        end
+
+        def key_for(operation)
+          # Note: We could have used the right_key here too, they're both the
+          # same keys
+          operation.respond_to?(:left_key) ? operation.left_key : operation.key
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module SuperDiff
+  module Basic
+    module OperationTreeFlatteners
+      class MultilineString < Core::AbstractOperationTreeFlattener
+        def build_tiered_lines
+          operation_tree.map do |operation|
+            Core::Line.new(
+              type: operation.name,
+              indentation_level: indentation_level,
+              # TODO: Test that quotes and things don't get escaped but escape
+              # characters do
+              value:
+                operation.value.inspect[1..-2].gsub(/\\"/, '"').gsub(/\\'/, "'")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/operation_tree_flatteners.rb

@@ -0,0 +1,24 @@
+module SuperDiff
+  module Basic
+    module OperationTreeFlatteners
+      autoload :Array, "super_diff/basic/operation_tree_flatteners/array"
+      autoload(
+        :Collection,
+        "super_diff/basic/operation_tree_flatteners/collection"
+      )
+      autoload(
+        :CustomObject,
+        "super_diff/basic/operation_tree_flatteners/custom_object"
+      )
+      autoload(
+        :DefaultObject,
+        "super_diff/basic/operation_tree_flatteners/default_object"
+      )
+      autoload :Hash, "super_diff/basic/operation_tree_flatteners/hash"
+      autoload(
+        :MultilineString,
+        "super_diff/basic/operation_tree_flatteners/multiline_string"
+      )
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module SuperDiff
+  module Basic
+    module OperationTrees
+      class Array < Core::AbstractOperationTree
+        def self.applies_to?(value)
+          value.is_a?(::Array)
+        end
+
+        protected
+
+        def operation_tree_flattener_class
+          OperationTreeFlatteners::Array
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module SuperDiff
+  module Basic
+    module OperationTrees
+      class CustomObject < DefaultObject
+        def self.applies_to?(value)
+          value.respond_to?(:attributes_for_super_diff)
+        end
+
+        protected
+
+        def operation_tree_flattener_class
+          OperationTreeFlatteners::CustomObject
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module SuperDiff
+  module Basic
+    module OperationTrees
+      class DefaultObject < Core::AbstractOperationTree
+        def self.applies_to?(*)
+          true
+        end
+
+        attr_reader :underlying_object
+
+        def initialize(operations, underlying_object:)
+          super(operations)
+          @underlying_object = underlying_object
+        end
+
+        def pretty_print(pp)
+          pp.text "#<#{self.class.name} "
+          pp.nest(1) do
+            pp.breakable
+            pp.text ":operations=>"
+            pp.group(1, "[", "]") do
+              pp.breakable
+              pp.seplist(self) { |value| pp.pp value }
+            end
+            pp.comma_breakable
+            pp.text ":underlying_object=>"
+            pp.object_address_group underlying_object do
+              # do nothing
+            end
+          end
+          pp.text ">"
+        end
+
+        protected
+
+        def operation_tree_flattener_class
+          OperationTreeFlatteners::DefaultObject
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module SuperDiff
+  module Basic
+    module OperationTrees
+      class Hash < Core::AbstractOperationTree
+        def self.applies_to?(value)
+          value.is_a?(::Hash)
+        end
+
+        protected
+
+        def operation_tree_flattener_class
+          OperationTreeFlatteners::Hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module SuperDiff
+  module Basic
+    module OperationTrees
+      class MultilineString < Core::AbstractOperationTree
+        def self.applies_to?(value)
+          value.is_a?(::String) && value.is_a?(::String)
+        end
+
+        protected
+
+        def operation_tree_flattener_class
+          OperationTreeFlatteners::MultilineString
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/basic/operation_trees.rb

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

data/lib/super_diff/basic.rb

@@ -0,0 +1,48 @@
+require "super_diff/basic/differs"
+require "super_diff/basic/inspection_tree_builders"
+require "super_diff/basic/operation_tree_builders"
+require "super_diff/basic/operation_tree_flatteners"
+require "super_diff/basic/operation_trees"
+
+module SuperDiff
+  module Basic
+    autoload :DiffFormatters, "super_diff/basic/diff_formatters"
+
+    SuperDiff.configuration.tap do |config|
+      config.add_extra_differ_classes(
+        Differs::Array,
+        Differs::Hash,
+        Differs::TimeLike,
+        Differs::DateLike,
+        Differs::MultilineString,
+        Differs::CustomObject,
+        Differs::DefaultObject
+      )
+
+      config.add_extra_inspection_tree_builder_classes(
+        InspectionTreeBuilders::CustomObject,
+        InspectionTreeBuilders::Array,
+        InspectionTreeBuilders::Hash,
+        InspectionTreeBuilders::Primitive,
+        InspectionTreeBuilders::TimeLike,
+        InspectionTreeBuilders::DateLike,
+        InspectionTreeBuilders::DefaultObject
+      )
+
+      config.add_extra_operation_tree_builder_classes(
+        OperationTreeBuilders::Array,
+        OperationTreeBuilders::Hash,
+        OperationTreeBuilders::TimeLike,
+        OperationTreeBuilders::DateLike,
+        OperationTreeBuilders::CustomObject
+      )
+
+      config.add_extra_operation_tree_classes(
+        OperationTrees::Array,
+        OperationTrees::Hash,
+        OperationTrees::CustomObject,
+        OperationTrees::DefaultObject
+      )
+    end
+  end
+end

data/lib/super_diff/{differs/base.rb → core/abstract_differ.rb}

@@ -1,6 +1,6 @@
 module SuperDiff
-  module Differs
-    class Base
+  module Core
+    class AbstractDiffer
       def self.applies_to?(_expected, _actual)
         raise NotImplementedError
       end

data/lib/super_diff/core/abstract_inspection_tree_builder.rb

@@ -0,0 +1,26 @@
+module SuperDiff
+  module Core
+    class AbstractInspectionTreeBuilder
+      extend AttrExtras.mixin
+      extend ImplementationChecks
+      include ImplementationChecks
+      include Helpers
+
+      def self.applies_to?(_value)
+        unimplemented_class_method!
+      end
+
+      method_object :object
+
+      def call
+        unimplemented_instance_method!
+      end
+
+      protected
+
+      def inspection_tree
+        unimplemented_instance_method!
+      end
+    end
+  end
+end

data/lib/super_diff/{operation_trees/base.rb → core/abstract_operation_tree.rb}

@@ -1,8 +1,8 @@
 require "forwardable"
 
 module SuperDiff
-  module OperationTrees
-    class Base
+  module Core
+    class AbstractOperationTree
       def self.applies_to?(*)
         unimplemented_class_method!
       end
@@ -46,6 +46,10 @@ module SuperDiff
         end
       end
 
+      def ==(other)
+        other.is_a?(self.class) && other.to_a == to_a
+      end
+
       private
 
       attr_reader :operations

data/lib/super_diff/{operation_tree_builders/base.rb → core/abstract_operation_tree_builder.rb}

@@ -1,6 +1,6 @@
 module SuperDiff
-  module OperationTreeBuilders
-    class Base
+  module Core
+    class AbstractOperationTreeBuilder
       def self.applies_to?(_expected, _actual)
         raise NotImplementedError
       end
@@ -48,7 +48,7 @@ module SuperDiff
                    possible_comparison_of(delete_operation, insert_operation)
                )
               operation_tree.delete(delete_operation)
-              operation_tree << Operations::BinaryOperation.new(
+              operation_tree << BinaryOperation.new(
                 name: :change,
                 left_collection: delete_operation.collection,
                 right_collection: insert_operation.collection,
@@ -89,11 +89,7 @@ module SuperDiff
       end
 
       def compare(expected, actual)
-        OperationTreeBuilders::Main.call(
-          expected: expected,
-          actual: actual,
-          all_or_nothing: false
-        )
+        SuperDiff.build_operation_tree_for(expected, actual)
       end
     end
   end

data/lib/super_diff/{operation_tree_flatteners/base.rb → core/abstract_operation_tree_flattener.rb}

@@ -1,6 +1,6 @@
 module SuperDiff
-  module OperationTreeFlatteners
-    class Base
+  module Core
+    class AbstractOperationTreeFlattener
       include ImplementationChecks
       extend AttrExtras.mixin
 

data/lib/super_diff/{operations → core}/binary_operation.rb

@@ -1,5 +1,5 @@
 module SuperDiff
-  module Operations
+  module Core
     class BinaryOperation
       extend AttrExtras.mixin
 

data/lib/super_diff/core/colorized_document_extensions.rb

@@ -0,0 +1,20 @@
+module SuperDiff
+  module Core
+    module ColorizedDocumentExtensions
+      def self.extended(extendee)
+        extendee.singleton_class.class_eval { alias_method :normal, :text }
+      end
+
+      %i[actual border elision_marker expected header].each do |method_name|
+        define_method(method_name) do |*args, **opts, &block|
+          colorize(
+            *args,
+            **opts,
+            fg: SuperDiff.configuration.public_send("#{method_name}_color"),
+            &block
+          )
+        end
+      end
+    end
+  end
+end