super_diff 0.11.0 → 0.12.1

data/lib/super_diff/operation_tree_builders/default_object.rb

@@ -1,119 +0,0 @@
-module SuperDiff
-  module OperationTreeBuilders
-    class DefaultObject < Base
-      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 be find_operation_tree_for?
-        OperationTrees::DefaultObject.new([], underlying_object: actual)
-      end
-
-      def find_operation_tree_for(value)
-        OperationTrees::Main.call(value)
-      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 << Operations::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 << Operations::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 << Operations::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

data/lib/super_diff/operation_tree_builders/defaults.rb

@@ -1,5 +0,0 @@
-module SuperDiff
-  module OperationTreeBuilders
-    DEFAULTS = [Array, Hash, TimeLike, DateLike, CustomObject].freeze
-  end
-end

data/lib/super_diff/operation_tree_builders/hash.rb

@@ -1,218 +0,0 @@
-module SuperDiff
-  module OperationTreeBuilders
-    class Hash < Base
-      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 << Operations::UnaryOperation.new(
-                    name: :delete,
-                    collection: expected,
-                    key: ek,
-                    value: ev2,
-                    index: ei2
-                  )
-                end
-              end
-            end
-
-            operations << Operations::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 << Operations::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 << Operations::UnaryOperation.new(
-                    name: :insert,
-                    collection: actual,
-                    key: ak,
-                    value: av,
-                    index: ai
-                  )
-                end
-              end
-            end
-
-            if (
-                 expected.include?(ak) && ev != av &&
-                   operations.none? { |op| op.name == :delete && op.key == ak }
-               )
-              # 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 << Operations::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 << Operations::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 << Operations::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

data/lib/super_diff/operation_tree_builders/multiline_string.rb

@@ -1,86 +0,0 @@
-module SuperDiff
-  module OperationTreeBuilders
-    class MultilineString < Base
-      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|
-          Operations::UnaryOperation.new(
-            name: :delete,
-            collection: expected,
-            key: index,
-            index: index,
-            value: expected[index]
-          )
-        end
-      end
-
-      def add_insert_operations(indices)
-        indices.map do |index|
-          Operations::UnaryOperation.new(
-            name: :insert,
-            collection: actual,
-            key: index,
-            index: index,
-            value: actual[index]
-          )
-        end
-      end
-
-      def add_noop_operations(indices)
-        indices.map do |index|
-          Operations::UnaryOperation.new(
-            name: :noop,
-            collection: actual,
-            key: index,
-            index: index,
-            value: actual[index]
-          )
-        end
-      end
-    end
-  end
-end

data/lib/super_diff/operation_tree_builders/time_like.rb

@@ -1,24 +0,0 @@
-module SuperDiff
-  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

data/lib/super_diff/operation_tree_flatteners/array.rb

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

data/lib/super_diff/operation_tree_flatteners/collection.rb

@@ -1,136 +0,0 @@
-module SuperDiff
-  module OperationTreeFlatteners
-    class Collection < Base
-      protected
-
-      def build_tiered_lines
-        [
-          Line.new(
-            type: :noop,
-            indentation_level: indentation_level,
-            value: open_token,
-            collection_bookend: :open
-          ),
-          *inner_lines,
-          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)
-        SuperDiff::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)
-          [
-            Line.new(
-              type: operation.name,
-              indentation_level: indentation_level,
-              value: SuperDiff::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) ||
-          SuperDiff::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

data/lib/super_diff/operation_tree_flatteners/custom_object.rb

@@ -1,28 +0,0 @@
-module SuperDiff
-  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

data/lib/super_diff/operation_tree_flatteners/default_object.rb

@@ -1,31 +0,0 @@
-module SuperDiff
-  module OperationTreeFlatteners
-    class DefaultObject < Collection
-      protected
-
-      def open_token
-        "#<#{operation_tree.underlying_object.class.name}:" +
-          SuperDiff::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

data/lib/super_diff/operation_tree_flatteners/hash.rb

@@ -1,33 +0,0 @@
-module SuperDiff
-  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