super_diff 0.10.0 → 0.12.0

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

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

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

@@ -0,0 +1,58 @@
+module SuperDiff
+  module Basic
+    module InspectionTreeBuilders
+      class TimeLike < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(value)
+          SuperDiff.time_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 %H:%M:%S") +
+                  (object.subsec == 0 ? "" : "+#{object.subsec.inspect}") +
+                  " " + object.strftime("%:z") +
+                  (object.zone ? " (#{object.zone})" : "")
+              )
+            end
+
+            t1.when_rendering_to_lines do |t2|
+              t2.nested do |t3|
+                t3.insert_separated_list(
+                  %i[year month day hour min sec subsec zone utc_offset]
+                ) 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.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

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

@@ -0,0 +1,42 @@
+module SuperDiff
+  module Basic
+    module OperationTreeBuilders
+      class CustomObject < DefaultObject
+        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 build_operation_tree
+          # NOTE: It doesn't matter whether we use expected or actual here,
+          # because all we care about is the name of the class
+          OperationTrees::CustomObject.new([], underlying_object: actual)
+        end
+
+        def attribute_names
+          expected.attributes_for_super_diff.keys &
+            actual.attributes_for_super_diff.keys
+        end
+
+        private
+
+        attr_reader :expected_attributes, :actual_attributes
+
+        def establish_expected_and_actual_attributes
+          @expected_attributes =
+            attribute_names.reduce({}) do |hash, name|
+              hash.merge(name => expected.public_send(name))
+            end
+
+          @actual_attributes =
+            attribute_names.reduce({}) do |hash, name|
+              hash.merge(name => actual.public_send(name))
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module SuperDiff
+  module Basic
+    module OperationTreeBuilders
+      class DateLike < CustomObject
+        def self.applies_to?(expected, actual)
+          SuperDiff.date_like?(expected) && SuperDiff.date_like?(actual)
+        end
+
+        protected
+
+        def attribute_names
+          %w[year month day]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+module SuperDiff
+  module Basic
+    module OperationTreeBuilders
+      class DefaultObject < Core::AbstractOperationTreeBuilder
+        def self.applies_to?(_expected, _actual)
+          true
+        end
+
+        def initialize(*args)
+          super(*args)
+
+          establish_expected_and_actual_attributes
+        end
+
+        protected
+
+        def unary_operations
+          attribute_names.reduce([]) do |operations, name|
+            possibly_add_noop_operation_to(operations, name)
+            possibly_add_delete_operation_to(operations, name)
+            possibly_add_insert_operation_to(operations, name)
+            operations
+          end
+        end
+
+        def build_operation_tree
+          # XXX This assumes that `expected` and `actual` are the same
+          # TODO: Does this need to find the operation tree matching `actual`?
+          OperationTrees::DefaultObject.new([], underlying_object: actual)
+        end
+
+        def attribute_names
+          (
+            expected.instance_variables.sort & actual.instance_variables.sort
+          ).map { |variable_name| variable_name[1..-1] }
+        end
+
+        private
+
+        attr_reader :expected_attributes, :actual_attributes
+
+        def establish_expected_and_actual_attributes
+          @expected_attributes =
+            attribute_names.reduce({}) do |hash, name|
+              hash.merge(name => expected.instance_variable_get("@#{name}"))
+            end
+
+          @actual_attributes =
+            attribute_names.reduce({}) do |hash, name|
+              hash.merge(name => actual.instance_variable_get("@#{name}"))
+            end
+        end
+
+        def possibly_add_noop_operation_to(operations, attribute_name)
+          if should_add_noop_operation?(attribute_name)
+            operations << Core::UnaryOperation.new(
+              name: :noop,
+              collection: actual_attributes,
+              key: attribute_name,
+              index: attribute_names.index(attribute_name),
+              value: actual_attributes[attribute_name]
+            )
+          end
+        end
+
+        def should_add_noop_operation?(attribute_name)
+          expected_attributes.include?(attribute_name) &&
+            actual_attributes.include?(attribute_name) &&
+            expected_attributes[attribute_name] ==
+              actual_attributes[attribute_name]
+        end
+
+        def possibly_add_delete_operation_to(operations, attribute_name)
+          if should_add_delete_operation?(attribute_name)
+            operations << Core::UnaryOperation.new(
+              name: :delete,
+              collection: expected_attributes,
+              key: attribute_name,
+              index: attribute_names.index(attribute_name),
+              value: expected_attributes[attribute_name]
+            )
+          end
+        end
+
+        def should_add_delete_operation?(attribute_name)
+          expected_attributes.include?(attribute_name) &&
+            (
+              !actual_attributes.include?(attribute_name) ||
+                expected_attributes[attribute_name] !=
+                  actual_attributes[attribute_name]
+            )
+        end
+
+        def possibly_add_insert_operation_to(operations, attribute_name)
+          if should_add_insert_operation?(attribute_name)
+            operations << Core::UnaryOperation.new(
+              name: :insert,
+              collection: actual_attributes,
+              key: attribute_name,
+              index: attribute_names.index(attribute_name),
+              value: actual_attributes[attribute_name]
+            )
+          end
+        end
+
+        def should_add_insert_operation?(attribute_name)
+          !expected_attributes.include?(attribute_name) ||
+            (
+              actual_attributes.include?(attribute_name) &&
+                expected_attributes[attribute_name] !=
+                  actual_attributes[attribute_name]
+            )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,222 @@
+module SuperDiff
+  module Basic
+    module OperationTreeBuilders
+      class Hash < Core::AbstractOperationTreeBuilder
+        def self.applies_to?(expected, actual)
+          expected.is_a?(::Hash) && actual.is_a?(::Hash)
+        end
+
+        protected
+
+        def unary_operations
+          unary_operations_using_variant_of_patience_algorithm
+        end
+
+        def build_operation_tree
+          OperationTrees::Hash.new([])
+        end
+
+        private
+
+        def unary_operations_using_variant_of_patience_algorithm
+          operations = []
+          aks, eks = actual.keys, expected.keys
+          previous_ei, ei = nil, 0
+          ai = 0
+
+          # When diffing a hash, we're more interested in the 'actual' version
+          # than the 'expected' version, because that's the ultimate truth.
+          # Therefore, the diff is presented from the perspective of the 'actual'
+          # hash, and we start off by looping over it.
+          while ai < aks.size
+            ak = aks[ai]
+            av, ev = actual[ak], expected[ak]
+            # While we iterate over 'actual' in order, we jump all over
+            # 'expected', trying to match up its keys with the keys in 'actual' as
+            # much as possible.
+            ei = eks.index(ak)
+
+            if should_add_noop_operation?(ak)
+              # (If we're here, it probably means that the key we're pointing to
+              # in the 'actual' and 'expected' hashes have the same value.)
+
+              if ei && previous_ei && (ei - previous_ei) > 1
+                # If we've jumped from one operation in the 'expected' hash to
+                # another operation later in 'expected' (due to the fact that the
+                # 'expected' hash is in a different order than 'actual'), collect
+                # any delete operations in between and add them to our operations
+                # array as deletes before adding the noop. If we don't do this
+                # now, then those deletes will disappear. (Again, we are mainly
+                # iterating over 'actual', so this is the only way to catch all of
+                # the keys in 'expected'.)
+                (previous_ei + 1).upto(ei - 1) do |ei2|
+                  ek = eks[ei2]
+                  ev2, av2 = expected[ek], actual[ek]
+
+                  if (
+                       (!actual.include?(ek) || ev2 != av2) &&
+                         operations.none? do |operation|
+                           %i[delete noop].include?(operation.name) &&
+                             operation.key == ek
+                         end
+                     )
+                    operations << Core::UnaryOperation.new(
+                      name: :delete,
+                      collection: expected,
+                      key: ek,
+                      value: ev2,
+                      index: ei2
+                    )
+                  end
+                end
+              end
+
+              operations << Core::UnaryOperation.new(
+                name: :noop,
+                collection: actual,
+                key: ak,
+                value: av,
+                index: ai
+              )
+            else
+              # (If we're here, it probably means that the key in 'actual' isn't
+              # present in 'expected' or the values don't match.)
+
+              if (
+                   (operations.empty? || operations.last.name == :noop) &&
+                     (ai == 0 || eks.include?(aks[ai - 1]))
+                 )
+                # If we go from a match in the last iteration to a missing or
+                # extra key in this one, or we're at the first key in 'actual' and
+                # it's missing or extra, look for deletes in the 'expected' hash
+                # and add them to our list of operations before we add the
+                # inserts. In most cases we will accomplish this by backtracking a
+                # bit to the key in 'expected' that matched the key in 'actual' we
+                # processed in the previous iteration (or just the first key in
+                # 'expected' if this is the first key in 'actual'), and then
+                # iterating from there through 'expected' until we reach the end
+                # or we hit some other condition (see below).
+
+                start_index =
+                  if ai > 0
+                    eks.index(aks[ai - 1]) + 1
+                  else
+                    0
+                  end
+
+                start_index.upto(eks.size - 1) do |ei2|
+                  ek = eks[ei2]
+                  ev, av2 = expected[ek], actual[ek]
+
+                  if actual.include?(ek) && ev == av2
+                    # If the key in 'expected' we've landed on happens to be a
+                    # match in 'actual', then stop, because it's going to be
+                    # handled in some future iteration of the 'actual' loop.
+                    break
+                  elsif (
+                        aks[ai + 1..-1].any? do |k|
+                          expected.include?(k) && expected[k] != actual[k]
+                        end
+                      )
+                    # While we backtracked a bit to iterate over 'expected', we
+                    # now have to look ahead. If we will end up encountering a
+                    # insert that matches this delete later, stop and go back to
+                    # iterating over 'actual'. This is because the delete we would
+                    # have added now will be added later when we encounter the
+                    # associated insert, so we don't want to add it twice.
+                    break
+                  else
+                    operations << Core::UnaryOperation.new(
+                      name: :delete,
+                      collection: expected,
+                      key: ek,
+                      value: ev,
+                      index: ei2
+                    )
+                  end
+
+                  if ek == ak && ev != av
+                    # If we're pointing to the same key in 'expected' as in
+                    # 'actual', but with different values, go ahead and add an
+                    # insert now to accompany the delete added above. That way
+                    # they appear together, which will be easier to read.
+                    operations << Core::UnaryOperation.new(
+                      name: :insert,
+                      collection: actual,
+                      key: ak,
+                      value: av,
+                      index: ai
+                    )
+                  end
+                end
+              end
+
+              if (
+                   expected.include?(ak) && ev != av &&
+                     operations.none? do |op|
+                       op.name == :delete && op.key == ak
+                     end
+                 )
+                # If we're here, it means that we didn't encounter any delete
+                # operations above for whatever reason and so we need to add a
+                # delete to represent the fact that the value for this key has
+                # changed.
+                operations << Core::UnaryOperation.new(
+                  name: :delete,
+                  collection: expected,
+                  key: ak,
+                  value: expected[ak],
+                  index: ei
+                )
+              end
+
+              if operations.none? { |op| op.name == :insert && op.key == ak }
+                # If we're here, it means that we didn't encounter any insert
+                # operations above. Since we already handled delete, the only
+                # alternative is that this key must not exist in 'expected', so
+                # we need to add an insert.
+                operations << Core::UnaryOperation.new(
+                  name: :insert,
+                  collection: actual,
+                  key: ak,
+                  value: av,
+                  index: ai
+                )
+              end
+            end
+
+            ai += 1
+            previous_ei = ei
+          end
+
+          # The last thing to do is this: if there are keys in 'expected' that
+          # aren't in 'actual', and they aren't associated with any inserts to
+          # where they would have been added above, tack those deletes onto the
+          # end of our operations array.
+          (eks - aks - operations.map(&:key)).each do |ek|
+            ei = eks.index(ek)
+            ev = expected[ek]
+
+            operations << Core::UnaryOperation.new(
+              name: :delete,
+              collection: expected,
+              key: ek,
+              value: ev,
+              index: ei
+            )
+          end
+
+          operations
+        end
+
+        def should_add_noop_operation?(key)
+          expected.include?(key) && expected[key] == actual[key]
+        end
+
+        def all_keys
+          actual.keys | expected.keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+require "patience_diff"
+
+module SuperDiff
+  module Basic
+    module OperationTreeBuilders
+      class MultilineString < Core::AbstractOperationTreeBuilder
+        def self.applies_to?(expected, actual)
+          expected.is_a?(::String) && actual.is_a?(::String) &&
+            (expected.include?("\n") || actual.include?("\n"))
+        end
+
+        def initialize(*args)
+          super(*args)
+
+          @original_expected = @expected
+          @original_actual = @actual
+          @expected = split_into_lines(@expected)
+          @actual = split_into_lines(@actual)
+          @sequence_matcher = PatienceDiff::SequenceMatcher.new
+        end
+
+        protected
+
+        def unary_operations
+          opcodes.flat_map do |code, a_start, a_end, b_start, b_end|
+            if code == :delete
+              add_delete_operations(a_start..a_end)
+            elsif code == :insert
+              add_insert_operations(b_start..b_end)
+            else
+              add_noop_operations(b_start..b_end)
+            end
+          end
+        end
+
+        def build_operation_tree
+          OperationTrees::MultilineString.new([])
+        end
+
+        private
+
+        attr_reader :sequence_matcher, :original_expected, :original_actual
+
+        def split_into_lines(string)
+          string.scan(/.+(?:\r|\n|\r\n|\Z)/)
+        end
+
+        def opcodes
+          sequence_matcher.diff_opcodes(expected, actual)
+        end
+
+        def add_delete_operations(indices)
+          indices.map do |index|
+            Core::UnaryOperation.new(
+              name: :delete,
+              collection: expected,
+              key: index,
+              index: index,
+              value: expected[index]
+            )
+          end
+        end
+
+        def add_insert_operations(indices)
+          indices.map do |index|
+            Core::UnaryOperation.new(
+              name: :insert,
+              collection: actual,
+              key: index,
+              index: index,
+              value: actual[index]
+            )
+          end
+        end
+
+        def add_noop_operations(indices)
+          indices.map do |index|
+            Core::UnaryOperation.new(
+              name: :noop,
+              collection: actual,
+              key: index,
+              index: index,
+              value: actual[index]
+            )
+          end
+        end
+      end
+    end
+  end
+end