super_diff 0.6.2 → 0.9.0

data/lib/super_diff/object_inspection/inspection_tree_builders.rb

@@ -0,0 +1,44 @@
+module SuperDiff
+  module ObjectInspection
+    module InspectionTreeBuilders
+      autoload(
+        :Base,
+        "super_diff/object_inspection/inspection_tree_builders/base",
+      )
+      autoload(
+        :Array,
+        "super_diff/object_inspection/inspection_tree_builders/array",
+      )
+      autoload(
+        :CustomObject,
+        "super_diff/object_inspection/inspection_tree_builders/custom_object",
+      )
+      autoload(
+        :DefaultObject,
+        "super_diff/object_inspection/inspection_tree_builders/default_object",
+      )
+      autoload(
+        :Hash,
+        "super_diff/object_inspection/inspection_tree_builders/hash",
+      )
+      autoload(
+        :Main,
+        "super_diff/object_inspection/inspection_tree_builders/main",
+      )
+      autoload(
+        :Primitive,
+        "super_diff/object_inspection/inspection_tree_builders/primitive",
+      )
+      autoload(
+        :String,
+        "super_diff/object_inspection/inspection_tree_builders/string",
+      )
+      autoload(
+        :TimeLike,
+        "super_diff/object_inspection/inspection_tree_builders/time_like",
+      )
+    end
+  end
+end
+
+require "super_diff/object_inspection/inspection_tree_builders/defaults"

data/lib/super_diff/object_inspection/nodes/as_lines_when_rendering_to_lines.rb

@@ -0,0 +1,97 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class AsLinesWhenRenderingToLines < Base
+        def self.node_name
+          :as_lines_when_rendering_to_lines
+        end
+
+        def self.method_name
+          :as_lines_when_rendering_to_lines
+        end
+
+        def initialize(
+          tree,
+          *args,
+          add_comma: false,
+          collection_bookend: nil,
+          **rest
+        )
+          super(tree, *args, **rest)
+
+          @add_comma = add_comma
+          @collection_bookend = collection_bookend
+        end
+
+        def render_to_string(object)
+          # TODO: This happens a lot, can we simplify this?
+          string =
+            if block
+              render_to_string_in_subtree(object)
+            else
+              immediate_value.to_s
+            end
+
+          if add_comma?
+            string + ","
+          else
+            string
+          end
+        end
+
+        def render_to_lines(object, type:, indentation_level:)
+          lines =
+            if block
+              render_to_lines_in_subtree(
+                object,
+                type: type,
+                indentation_level: indentation_level,
+                disallowed_node_names: [
+                  :line,
+                  :as_lines_when_rendering_to_lines,
+                ],
+              )
+            else
+              [
+                SuperDiff::Line.new(
+                  type: type,
+                  indentation_level: indentation_level,
+                  value: immediate_value.to_s,
+                ),
+              ]
+            end
+
+          with_collection_bookend_added_to_last_line_in(
+            with_add_comma_added_to_last_line_in(lines),
+          )
+        end
+
+        private
+
+        attr_reader :collection_bookend
+
+        def add_comma?
+          @add_comma
+        end
+
+        def with_collection_bookend_added_to_last_line_in(lines)
+          if collection_bookend
+            lines[0..-2] + [
+              lines[-1].clone_with(collection_bookend: collection_bookend),
+            ]
+          else
+            lines
+          end
+        end
+
+        def with_add_comma_added_to_last_line_in(lines)
+          if add_comma?
+            lines[0..-2] + [lines[-1].clone_with(add_comma: add_comma?)]
+          else
+            lines
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/as_prefix_when_rendering_to_lines.rb

@@ -0,0 +1,27 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class AsPrefixWhenRenderingToLines < Base
+        def self.name
+          :as_prefix_when_rendering_to_lines
+        end
+
+        def self.method_name
+          :as_prefix_when_rendering_to_lines
+        end
+
+        def render_to_string(object)
+          if block
+            render_to_string_in_subtree(object)
+          else
+            immediate_value.to_s
+          end
+        end
+
+        def render_to_lines(object, **)
+          ObjectInspection::PrefixForNextNode.new(render_to_string(object))
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/as_prelude_when_rendering_to_lines.rb

@@ -0,0 +1,27 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class AsPreludeWhenRenderingToLines < Base
+        def self.name
+          :as_prelude_when_rendering_to_lines
+        end
+
+        def self.method_name
+          :as_prelude_when_rendering_to_lines
+        end
+
+        def render_to_string(object)
+          if block
+            render_to_string_in_subtree(object)
+          else
+            immediate_value.to_s
+          end
+        end
+
+        def render_to_lines(object, **)
+          ObjectInspection::PreludeForNextNode.new(render_to_string(object))
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/as_single_line.rb

@@ -0,0 +1,33 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class AsSingleLine < Base
+        def self.node_name
+          :as_single_line
+        end
+
+        def self.method_name
+          :as_single_line
+        end
+
+        def render_to_string(object)
+          if block
+            render_to_string_in_subtree(object)
+          else
+            immediate_value.to_s
+          end
+        end
+
+        def render_to_lines(object, type:, indentation_level:)
+          [
+            SuperDiff::Line.new(
+              type: type,
+              indentation_level: indentation_level,
+              value: render_to_string(object),
+            ),
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/base.rb

@@ -2,7 +2,18 @@ module SuperDiff
   module ObjectInspection
     module Nodes
       class Base
-        def initialize(tree, *args, &block)
+        def self.node_name
+          unimplemented_class_method!
+        end
+
+        def self.method_name
+          unimplemented_class_method!
+        end
+
+        include ImplementationChecks
+        extend ImplementationChecks
+
+        def initialize(tree, *args, **options, &block)
           if !args.empty? && block
             raise ArgumentError.new(
               "You cannot provide both an immediate value and a lazy value. " +
@@ -13,35 +24,40 @@ module SuperDiff
           @tree = tree
           @immediate_value = args.first
           @block = block
+          @options = options
         end
 
         def clone_with(
           tree: @tree,
           immediate_value: @immediate_value,
-          block: @block
+          block: @block,
+          **rest
         )
           if block
-            self.class.new(tree, &block)
+            self.class.new(tree, **options, **rest, &block)
           else
-            self.class.new(tree, immediate_value)
+            self.class.new(tree, immediate_value, **options, **rest)
           end
         end
 
-        def type
-          self.class.name.
-            sub(/^(.+)::(.+?)$/, '\2').
-            gsub(/([a-z])([A-Z])/, '\1_\2').
-            downcase.
-            to_sym
+        def render(object, preferably_as_lines:, **rest)
+          if options[:as_lines] || preferably_as_lines
+            render_to_lines(object, **rest)
+          else
+            render_to_string(object)
+          end
         end
 
         # rubocop:disable Lint/UnusedMethodArgument
-        def evaluate(object, indent_level:, as_single_line:)
+        def render_to_string(object)
         # rubocop:enable Lint/UnusedMethodArgument
-          raise NotImplementedError.new(
-            "Your node must provide an #evaluate method. " +
-            "(Keep in mind #evaluate may be called more than once for a node!)",
-          )
+          unimplemented_instance_method!
+        end
+
+        # rubocop:disable Lint/UnusedMethodArgument
+        def render_to_lines(object, type:, indentation_level:)
+        # rubocop:enable Lint/UnusedMethodArgument
+          unimplemented_instance_method!
         end
 
         def pretty_print(pp)
@@ -61,7 +77,7 @@ module SuperDiff
 
         private
 
-        attr_reader :tree, :immediate_value, :block
+        attr_reader :tree, :immediate_value, :block, :options
 
         def pretty_print_variables
           if block
@@ -71,13 +87,32 @@ module SuperDiff
           end
         end
 
-        def evaluate_in_subtree(object, indent_level:, as_single_line:)
+        def evaluate_block(object)
+          tree.evaluate_block(object, &block)
+        end
+
+        def render_to_string_in_subtree(object)
           subtree = InspectionTree.new
           subtree.evaluate_block(object, &block)
-          subtree.evaluate(
+          subtree.render_to_string(object)
+        end
+
+        def render_to_lines_in_subtree(
+          object,
+          type:,
+          indentation_level:,
+          disallowed_node_names: [],
+          **rest
+        )
+          subtree = InspectionTree.new(
+            disallowed_node_names: disallowed_node_names,
+          )
+          subtree.evaluate_block(object, &block)
+          subtree.render_to_lines(
             object,
-            indent_level: indent_level,
-            as_single_line: as_single_line,
+            type: type,
+            indentation_level: indentation_level,
+            **rest,
           )
         end
       end

data/lib/super_diff/object_inspection/nodes/inspection.rb

@@ -2,19 +2,59 @@ module SuperDiff
   module ObjectInspection
     module Nodes
       class Inspection < Base
-        def evaluate(object, indent_level:, as_single_line:)
+        def self.node_name
+          :inspection
+        end
+
+        def self.method_name
+          :add_inspection_of
+        end
+
+        def render_to_string(object)
+          value =
+            if block
+              evaluate_block(object)
+            else
+              immediate_value
+            end
+
+          SuperDiff::RecursionGuard.
+            guarding_recursion_of(value) do |already_seen|
+              if already_seen
+                SuperDiff::RecursionGuard::PLACEHOLDER
+              else
+                SuperDiff.inspect_object(value, as_lines: false)
+              end
+            end
+        end
+
+        def render_to_lines(object, type:, indentation_level:)
           value =
             if block
-              tree.evaluate_block(object, &block)
+              evaluate_block(object)
             else
               immediate_value
             end
 
-          SuperDiff.inspect_object(
-            value,
-            indent_level: indent_level,
-            as_single_line: as_single_line,
-          )
+          SuperDiff::RecursionGuard.
+            guarding_recursion_of(value) do |already_seen|
+              if already_seen
+                [
+                  SuperDiff::Line.new(
+                    type: type,
+                    indentation_level: indentation_level,
+                    value: SuperDiff::RecursionGuard::PLACEHOLDER,
+                  ),
+                ]
+              else
+                SuperDiff.inspect_object(
+                  value,
+                  as_lines: true,
+                  type: type,
+                  indentation_level: indentation_level,
+                )
+              end
+            end
         end
       end
     end

data/lib/super_diff/object_inspection/nodes/nesting.rb

@@ -2,12 +2,23 @@ module SuperDiff
   module ObjectInspection
     module Nodes
       class Nesting < Base
-        def evaluate(object, indent_level:, as_single_line:)
-          evaluate_in_subtree(
+        def self.node_name
+          :nesting
+        end
+
+        def self.method_name
+          :nested
+        end
+
+        def render_to_string(object)
+          render_to_string_in_subtree(object)
+        end
+
+        def render_to_lines(object, type:, indentation_level:)
+          render_to_lines_in_subtree(
             object,
-            indent_level: indent_level + 1,
-            as_single_line: as_single_line,
-            &block
+            type: type,
+            indentation_level: indentation_level + 1,
           )
         end
       end

data/lib/super_diff/object_inspection/nodes/only_when.rb

@@ -0,0 +1,54 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class OnlyWhen < Base
+        def self.node_name
+          :only_when
+        end
+
+        def self.method_name
+          :only_when
+        end
+
+        def initialize(tree, test, **options, &block)
+          @tree = tree
+          @test = test
+          @block = block
+          @options = options
+        end
+
+        def render_to_string(object)
+          if test_passes?
+            render_to_string_in_subtree(object)
+          else
+            ""
+          end
+        end
+
+        def render_to_lines(object, type:, indentation_level:)
+          if test_passes?
+            render_to_lines_in_subtree(
+              object,
+              type: type,
+              indentation_level: indentation_level,
+            )
+          else
+            []
+          end
+        end
+
+        private
+
+        attr_reader :test
+
+        def test_passes?
+          if test.arity == 1
+            test.call(object)
+          else
+            test.call
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/text.rb

@@ -2,13 +2,27 @@ module SuperDiff
   module ObjectInspection
     module Nodes
       class Text < Base
-        def evaluate(object, **)
+        def self.node_name
+          :text
+        end
+
+        def self.method_name
+          :add_text
+        end
+
+        def render_to_string(object)
           if block
-            tree.evaluate_block(object, &block).to_s
+            evaluate_block(object).to_s
           else
             immediate_value.to_s
           end
         end
+
+        def render_to_lines(object, **)
+          # NOTE: This is a bit of a hack since it returns a string instead of a
+          # Line, but it is handled in InspectionTree (see UpdateTieredLines)
+          render_to_string(object)
+        end
       end
     end
   end

data/lib/super_diff/object_inspection/nodes/when_empty.rb

@@ -2,16 +2,31 @@ module SuperDiff
   module ObjectInspection
     module Nodes
       class WhenEmpty < Base
-        def evaluate(object, indent_level:, as_single_line:)
+        def self.node_name
+          :when_empty
+        end
+
+        def self.method_name
+          :when_empty
+        end
+
+        def render_to_string(object)
           if empty?(object)
-            evaluate_in_subtree(
+            render_to_string_in_subtree(object)
+          else
+            ""
+          end
+        end
+
+        def render_to_lines(object, type:, indentation_level:)
+          if empty?(object)
+            render_to_lines_in_subtree(
               object,
-              indent_level: indent_level,
-              as_single_line: as_single_line,
-              &block
+              type: type,
+              indentation_level: indentation_level,
             )
           else
-            ""
+            []
           end
         end
 

data/lib/super_diff/object_inspection/nodes/when_non_empty.rb

@@ -2,15 +2,30 @@ module SuperDiff
   module ObjectInspection
     module Nodes
       class WhenNonEmpty < Base
-        def evaluate(object, indent_level:, as_single_line:)
+        def self.node_name
+          :when_non_empty
+        end
+
+        def self.method_name
+          :when_non_empty
+        end
+
+        def render_to_string(object)
           if empty?(object)
             ""
           else
-            evaluate_in_subtree(
+            render_to_string_in_subtree(object)
+          end
+        end
+
+        def render_to_lines(object, type:, indentation_level:)
+          if empty?(object)
+            []
+          else
+            render_to_lines_in_subtree(
               object,
-              indent_level: indent_level,
-              as_single_line: as_single_line,
-              &block
+              type: type,
+              indentation_level: indentation_level,
             )
           end
         end

data/lib/super_diff/object_inspection/nodes/when_rendering_to_lines.rb

@@ -0,0 +1,27 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class WhenRenderingToLines < Base
+        def self.node_name
+          :when_rendering_to_lines
+        end
+
+        def self.method_name
+          :when_rendering_to_lines
+        end
+
+        def render_to_string(*)
+          ""
+        end
+
+        def render_to_lines(object, type:, indentation_level:)
+          render_to_lines_in_subtree(
+            object,
+            type: type,
+            indentation_level: indentation_level,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/object_inspection/nodes/when_rendering_to_string.rb

@@ -0,0 +1,27 @@
+module SuperDiff
+  module ObjectInspection
+    module Nodes
+      class WhenRenderingToString < Base
+        def self.node_name
+          :when_rendering_to_string
+        end
+
+        def self.method_name
+          :when_rendering_to_string
+        end
+
+        def render_to_string(object)
+          if block
+            render_to_string_in_subtree(object)
+          else
+            immediate_value.to_s
+          end
+        end
+
+        def render_to_lines(*, **)
+          []
+        end
+      end
+    end
+  end
+end