super_diff 0.7.0 → 0.8.0

data/lib/super_diff/operation_tree_flatteners/collection.rb

@@ -0,0 +1,139 @@
+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

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,41 @@
+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)
+
+        if format_keys_as_kwargs?
+          "#{key}: "
+        else
+          "#{key.inspect} => "
+        end
+      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
+        if operation.respond_to?(:left_key)
+          operation.left_key
+        else
+          operation.key
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/operation_tree_flatteners/multiline_string.rb

@@ -0,0 +1,17 @@
+module SuperDiff
+  module OperationTreeFlatteners
+    class MultilineString < Base
+      def build_tiered_lines
+        operation_tree.map do |operation|
+          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

data/lib/super_diff/operation_trees/array.rb

@@ -5,13 +5,10 @@ module SuperDiff
         value.is_a?(::Array)
       end
 
-      def to_diff(indent_level:, collection_prefix:, add_comma:)
-        DiffFormatters::Array.call(
-          self,
-          indent_level: indent_level,
-          collection_prefix: collection_prefix,
-          add_comma: add_comma,
-        )
+      protected
+
+      def operation_tree_flattener_class
+        OperationTreeFlatteners::Array
       end
     end
   end

data/lib/super_diff/operation_trees/base.rb

@@ -1,33 +1,56 @@
-require 'delegate'
+require "forwardable"
 
 module SuperDiff
   module OperationTrees
-    class Base < SimpleDelegator
-      def self.applies_to?(_value)
+    class Base
+      def self.applies_to?(*)
         unimplemented_class_method!
       end
 
+      include Enumerable
+      include ImplementationChecks
       extend ImplementationChecks
+      extend Forwardable
 
-      # rubocop:disable Lint/UnusedMethodArgument
-      def to_diff(indent_level:, add_comma: false, collection_prefix: nil)
-        raise NotImplementedError
+      def_delegators :operations, :<<, :delete, :each
+
+      def initialize(operations)
+        @operations = operations
+      end
+
+      def to_diff(indentation_level:)
+        TieredLinesFormatter.call(
+          perhaps_elide(flatten(indentation_level: indentation_level)),
+        )
+      end
+
+      def flatten(indentation_level:)
+        operation_tree_flattener_class.call(
+          self,
+          indentation_level: indentation_level,
+        )
       end
-      # rubocop:enable Lint/UnusedMethodArgument
 
       def pretty_print(pp)
-        pp.text "#{self.class.name}.new(["
-        pp.group_sub do
-          pp.nest(2) do
-            pp.breakable
-            pp.seplist(self) do |value|
-              pp.pp value
-            end
+        pp.group(1, "#<#{self.class.name} [", "]>") do
+          pp.breakable
+          pp.seplist(self) do |value|
+            pp.pp value
           end
         end
-        pp.breakable
-        pp.text("])")
       end
+
+      def perhaps_elide(tiered_lines)
+        if SuperDiff.configuration.diff_elision_enabled?
+          TieredLinesElider.call(tiered_lines)
+        else
+          tiered_lines
+        end
+      end
+
+      private
+
+      attr_reader :operations
     end
   end
 end

data/lib/super_diff/operation_trees/custom_object.rb

@@ -5,14 +5,10 @@ module SuperDiff
         value.respond_to?(:attributes_for_super_diff)
       end
 
-      def to_diff(indent_level:, add_comma: false, collection_prefix: nil)
-        DiffFormatters::CustomObject.call(
-          self,
-          indent_level: indent_level,
-          collection_prefix: collection_prefix,
-          add_comma: add_comma,
-          value_class: value_class,
-        )
+      protected
+
+      def operation_tree_flattener_class
+        OperationTreeFlatteners::CustomObject
       end
     end
   end

data/lib/super_diff/operation_trees/default_object.rb

@@ -1,26 +1,41 @@
 module SuperDiff
   module OperationTrees
     class DefaultObject < Base
-      def self.applies_to?(_value)
+      def self.applies_to?(*)
         true
       end
 
-      attr_reader :value_class
+      attr_reader :underlying_object
 
-      # TODO: Default this to collection.class?
-      def initialize(collection, value_class:)
-        super(collection)
+      def initialize(operations, underlying_object:)
+        super(operations)
+        @underlying_object = underlying_object
+      end
 
-        @value_class = value_class
+      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) do |value|
+              pp.pp value
+            end
+          end
+          pp.comma_breakable
+          pp.text ":underlying_object=>"
+          pp.object_address_group underlying_object do
+            # do nothing
+          end
+        end
+        pp.text ">"
       end
 
-      def to_diff(indent_level:, add_comma: false, **_rest)
-        DiffFormatters::Main.call(
-          self,
-          indent_level: indent_level,
-          add_comma: add_comma,
-          value_class: value_class,
-        )
+      protected
+
+      def operation_tree_flattener_class
+        OperationTreeFlatteners::DefaultObject
       end
     end
   end

data/lib/super_diff/operation_trees/hash.rb

@@ -5,13 +5,10 @@ module SuperDiff
         value.is_a?(::Hash)
       end
 
-      def to_diff(indent_level:, collection_prefix:, add_comma:)
-        DiffFormatters::Hash.call(
-          self,
-          indent_level: indent_level,
-          collection_prefix: collection_prefix,
-          add_comma: add_comma,
-        )
+      protected
+
+      def operation_tree_flattener_class
+        OperationTreeFlatteners::Hash
       end
     end
   end