super_diff 0.10.0 → 0.12.0

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,24 +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
+      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/basic/inspection_tree_builders/array.rb

@@ -0,0 +1,53 @@
+module SuperDiff
+  module Basic
+    module InspectionTreeBuilders
+      class Array < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(value)
+          value.is_a?(::Array)
+        end
+
+        def call
+          Core::InspectionTree.new do |t1|
+            t1.only_when empty do |t2|
+              # stree-ignore
+              t2.as_lines_when_rendering_to_lines do |t3|
+                t3.add_text "[]"
+              end
+            end
+
+            t1.only_when nonempty do |t2|
+              # stree-ignore
+              t2.as_lines_when_rendering_to_lines(
+                collection_bookend: :open
+              ) do |t3|
+                t3.add_text "["
+              end
+
+              # stree-ignore
+              t2.nested do |t3|
+                t3.insert_array_inspection_of(object)
+              end
+
+              # stree-ignore
+              t2.as_lines_when_rendering_to_lines(
+                collection_bookend: :close
+              ) do |t3|
+                t3.add_text "]"
+              end
+            end
+          end
+        end
+
+        private
+
+        def empty
+          -> { object.empty? }
+        end
+
+        def nonempty
+          -> { !object.empty? }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module SuperDiff
+  module Basic
+    module InspectionTreeBuilders
+      class CustomObject < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(value)
+          value.respond_to?(:attributes_for_super_diff)
+        end
+
+        def call
+          Core::InspectionTree.new do |t1|
+            t1.as_lines_when_rendering_to_lines(
+              collection_bookend: :open
+            ) do |t2|
+              t2.add_text "#<#{object.class} "
+
+              # stree-ignore
+              t2.when_rendering_to_lines do |t3|
+                t3.add_text "{"
+              end
+            end
+
+            t1.nested do |t2|
+              t2.insert_hash_inspection_of(object.attributes_for_super_diff)
+            end
+
+            t1.as_lines_when_rendering_to_lines(
+              collection_bookend: :close
+            ) do |t2|
+              # stree-ignore
+              t2.when_rendering_to_lines do |t3|
+                t3.add_text "}"
+              end
+
+              t2.add_text ">"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module SuperDiff
+  module Basic
+    module InspectionTreeBuilders
+      class DateLike < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(value)
+          SuperDiff.date_like?(value)
+        end
+
+        def call
+          Core::InspectionTree.new do |t1|
+            t1.as_lines_when_rendering_to_lines(
+              collection_bookend: :open
+            ) do |t2|
+              t2.add_text "#<#{object.class} "
+
+              # stree-ignore
+              t2.when_rendering_to_lines do |t3|
+                t3.add_text "{"
+              end
+            end
+
+            t1.when_rendering_to_string do |t2|
+              t2.add_text object.strftime("%Y-%m-%d")
+            end
+
+            t1.when_rendering_to_lines do |t2|
+              t2.nested do |t3|
+                t3.insert_separated_list(%i[year month day]) do |t4, name|
+                  t4.add_text name.to_s
+                  t4.add_text ": "
+                  t4.add_inspection_of object.public_send(name)
+                end
+              end
+            end
+
+            t1.as_lines_when_rendering_to_lines(
+              collection_bookend: :close
+            ) do |t2|
+              # stree-ignore
+              t2.when_rendering_to_lines do |t3|
+                t3.add_text "}"
+              end
+
+              t2.add_text ">"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module SuperDiff
+  module Basic
+    module InspectionTreeBuilders
+      class DefaultObject < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(_value)
+          true
+        end
+
+        def call
+          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}:" + object_address_for(object) + ">"
+                )
+              end
+            end
+
+            t1.only_when nonempty do |t2|
+              t2.as_lines_when_rendering_to_lines(
+                collection_bookend: :open
+              ) do |t3|
+                t3.add_text(
+                  "#<#{object.class.name}:" + object_address_for(object)
+                )
+
+                # stree-ignore
+                t3.when_rendering_to_lines do |t4|
+                  t4.add_text " {"
+                end
+              end
+
+              # stree-ignore
+              t2.when_rendering_to_string do |t3|
+                t3.add_text " "
+              end
+
+              t2.nested do |t3|
+                t3.insert_separated_list(
+                  object.instance_variables.sort
+                ) do |t4, name|
+                  # stree-ignore
+                  t4.as_prefix_when_rendering_to_lines do |t5|
+                    t5.add_text "#{name}="
+                  end
+
+                  t4.add_inspection_of object.instance_variable_get(name)
+                end
+              end
+
+              t2.as_lines_when_rendering_to_lines(
+                collection_bookend: :close
+              ) do |t3|
+                # stree-ignore
+                t3.when_rendering_to_lines do |t4|
+                  t4.add_text "}"
+                end
+
+                t3.add_text ">"
+              end
+            end
+          end
+        end
+
+        private
+
+        def empty
+          -> { object.instance_variables.empty? }
+        end
+
+        def nonempty
+          -> { !object.instance_variables.empty? }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module SuperDiff
+  module Basic
+    module InspectionTreeBuilders
+      class Hash < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(value)
+          value.is_a?(::Hash)
+        end
+
+        def call
+          Core::InspectionTree.new do |t1|
+            t1.only_when empty do |t2|
+              # stree-ignore
+              t2.as_lines_when_rendering_to_lines do |t3|
+                t3.add_text "{}"
+              end
+            end
+
+            t1.only_when nonempty do |t2|
+              # stree-ignore
+              t2.as_lines_when_rendering_to_lines(
+                collection_bookend: :open
+              ) do |t3|
+                t3.add_text "{"
+              end
+
+              # stree-ignore
+              t2.when_rendering_to_string do |t3|
+                t3.add_text " "
+              end
+
+              # stree-ignore
+              t2.nested do |t3|
+                t3.insert_hash_inspection_of(object)
+              end
+
+              # stree-ignore
+              t2.when_rendering_to_string do |t3|
+                t3.add_text " "
+              end
+
+              # stree-ignore
+              t2.as_lines_when_rendering_to_lines(
+                collection_bookend: :close
+              ) do |t3|
+                t3.add_text "}"
+              end
+            end
+          end
+        end
+
+        private
+
+        def empty
+          -> { object.empty? }
+        end
+
+        def nonempty
+          -> { !object.empty? }
+        end
+      end
+    end
+  end
+end