super_diff 0.5.3 → 0.8.0

data/lib/super_diff/object_inspection.rb

@@ -1,15 +1,18 @@
 module SuperDiff
   module ObjectInspection
     autoload :InspectionTree, "super_diff/object_inspection/inspection_tree"
-    autoload :Inspectors, "super_diff/object_inspection/inspectors"
+    autoload(
+      :InspectionTreeBuilders,
+      "super_diff/object_inspection/inspection_tree_builders",
+    )
     autoload :Nodes, "super_diff/object_inspection/nodes"
-
-    def self.inspect(object, as_single_line:, indent_level: 0)
-      Inspectors::Main.call(
-        object,
-        as_single_line: as_single_line,
-        indent_level: indent_level,
-      )
-    end
+    autoload(
+      :PrefixForNextNode,
+      "super_diff/object_inspection/prefix_for_next_node",
+    )
+    autoload(
+      :PreludeForNextNode,
+      "super_diff/object_inspection/prelude_for_next_node",
+    )
   end
 end

data/lib/super_diff/object_inspection/inspection_tree.rb

@@ -3,7 +3,8 @@ module SuperDiff
     class InspectionTree
       include Enumerable
 
-      def initialize(&block)
+      def initialize(disallowed_node_names: [], &block)
+        @disallowed_node_names = disallowed_node_names
         @nodes = []
 
         if block
@@ -11,6 +12,12 @@ module SuperDiff
         end
       end
 
+      Nodes.registry.each do |node_class|
+        define_method(node_class.method_name) do |*args, **options, &block|
+          add_node(node_class, *args, **options, &block)
+        end
+      end
+
       def each(&block)
         nodes.each(&block)
       end
@@ -19,129 +26,224 @@ module SuperDiff
         @_before_each_callbacks ||= Hash.new { |h, k| h[k] = [] }
       end
 
-      def evaluate(object, as_single_line:, indent_level:)
-        nodes.reduce("") do |str, node|
-          str << node.evaluate(
-            object,
-            as_single_line: as_single_line,
-            indent_level: indent_level,
-          )
+      def render_to_string(object)
+        nodes.reduce("") do |string, node|
+          result = node.render_to_string(object)
+          string + result
         end
       end
 
-      def evaluate_block(object, &block)
-        instance_exec(object, &block)
-      end
-
-      def add_text(*args, &block)
-        add_node :text, *args, &block
-      end
-
-      def when_multiline(&block)
-        add_node :when_multiline, &block
-      end
-
-      def when_singleline(&block)
-        add_node :when_singleline, &block
-      end
-
-      def add_break(*args, &block)
-        add_node :break, *args, &block
-      end
-
-      def nested(&block)
-        add_node :nesting, &block
-      end
-
-      def when_empty(&block)
-        add_node :when_empty, &block
+      def render_to_lines(object, type:, indentation_level:)
+        nodes.
+          each_with_index.
+          reduce([TieredLines.new, "", ""]) do |
+            (tiered_lines, prelude, prefix),
+            (node, index)
+          |
+            UpdateTieredLines.call(
+              object: object,
+              type: type,
+              indentation_level: indentation_level,
+              nodes: nodes,
+              tiered_lines: tiered_lines,
+              prelude: prelude,
+              prefix: prefix,
+              node: node,
+              index: index,
+            )
+          end.
+          first
       end
 
-      def when_non_empty(&block)
-        add_node :when_non_empty, &block
+      def evaluate_block(object, &block)
+        instance_exec(object, &block)
       end
 
       def insert_array_inspection_of(array)
-        # FIXME: why must this be inside the `nested`?
-        add_break
-
         insert_separated_list(array) do |value|
-          add_inspection_of value
+          # Have to do these shenanigans so that if value is a hash, Ruby
+          # doesn't try to interpret it as keyword args
+          if SuperDiff::Helpers.ruby_version_matches?(">= 2.7.1")
+            add_inspection_of(value, **{})
+          else
+            add_inspection_of(*[value, {}])
+          end
         end
       end
 
-      def insert_hash_inspection_of(hash, initial_break: " ")
-        # FIXME: why must this be inside the `nested`?
-        add_break initial_break
+      def insert_hash_inspection_of(hash)
+        keys = hash.keys
 
-        format_keys_as_kwargs = hash.keys.all? do |key|
+        format_keys_as_kwargs = keys.all? do |key|
           key.is_a?(Symbol)
         end
 
-        insert_separated_list(hash) do |(key, value)|
+        insert_separated_list(keys) do |key|
           if format_keys_as_kwargs
-            add_text key
-            add_text ": "
+            as_prefix_when_rendering_to_lines do
+              add_text "#{key}: "
+            end
           else
-            add_inspection_of key
-            add_text " => "
+            as_prefix_when_rendering_to_lines do
+              add_inspection_of key, as_lines: false
+              add_text " => "
+            end
           end
 
-          add_inspection_of value
+          # Have to do these shenanigans so that if hash[key] is a hash, Ruby
+          # doesn't try to interpret it as keyword args
+          if SuperDiff::Helpers.ruby_version_matches?(">= 2.7.1")
+            add_inspection_of(hash[key], **{})
+          else
+            add_inspection_of(*[hash[key], {}])
+          end
         end
       end
 
-      def insert_separated_list(enumerable, separator: ",")
+      def insert_separated_list(enumerable, &block)
         enumerable.each_with_index do |value, index|
-          if index > 0
-            if separator.is_a?(Nodes::Base)
-              append_node separator
-            else
-              add_text separator
+          as_lines_when_rendering_to_lines(
+            add_comma: index < enumerable.size - 1,
+          ) do
+            if index > 0
+              when_rendering_to_string do
+                add_text " "
+              end
             end
 
-            add_break " "
+            evaluate_block(value, &block)
           end
-
-          yield value
-        end
-      end
-
-      def add_inspection_of(value = nil, &block)
-        if block
-          add_node :inspection, &block
-        else
-          add_node :inspection, value
-        end
-      end
-
-      def apply_tree(tree)
-        tree.each do |node|
-          append_node(node.clone_with(tree: self))
         end
       end
 
       private
 
-      attr_reader :nodes
+      attr_reader :disallowed_node_names, :nodes
 
-      def add_node(type, *args, &block)
-        append_node(build_node(type, *args, &block))
+      def add_node(node_class, *args, **options, &block)
+        if disallowed_node_names.include?(node_class.name)
+          raise DisallowedNodeError.create(node_name: node_class.name)
+        end
+
+        append_node(build_node(node_class, *args, **options, &block))
       end
 
       def append_node(node)
         nodes.push(node)
       end
 
-      def build_node(type, *args, &block)
-        Nodes.fetch(type).new(self, *args, &block)
+      def build_node(node_class, *args, **options, &block)
+        node_class.new(self, *args, **options, &block)
       end
 
-      class BlockArgument
+      class UpdateTieredLines
         extend AttrExtras.mixin
 
-        rattr_initialize [:object!, :as_single_line!]
-        attr_query :as_single_line?
+        method_object [
+          :object!,
+          :type!,
+          :indentation_level!,
+          :nodes!,
+          :tiered_lines!,
+          :prelude!,
+          :prefix!,
+          :node!,
+          :index!
+        ]
+
+        def call
+          if rendering.is_a?(Array)
+            concat_with_lines
+          elsif rendering.is_a?(PrefixForNextNode)
+            add_to_prefix
+          elsif tiered_lines.any?
+            add_to_last_line
+          elsif index < nodes.size - 1 || rendering.is_a?(PreludeForNextNode)
+            add_to_prelude
+          else
+            add_to_lines
+          end
+        end
+
+        private
+
+        def concat_with_lines
+          additional_lines = prefix_with(
+            prefix,
+            prepend_with(prelude, rendering),
+          )
+          [tiered_lines + additional_lines, "", ""]
+        end
+
+        def prefix_with(prefix, text)
+          if prefix.empty?
+            text
+          else
+            [text[0].prefixed_with(prefix)] + text[1..-1]
+          end
+        end
+
+        def prepend_with(prelude, text)
+          if prelude.empty?
+            text
+          else
+            [text[0].with_value_prepended(prelude)] + text[1..-1]
+          end
+        end
+
+        def add_to_prefix
+          [tiered_lines, prelude, rendering + prefix]
+        end
+
+        def add_to_last_line
+          new_lines = tiered_lines[0..-2] + [
+            tiered_lines[-1].with_value_appended(rendering),
+          ]
+          [new_lines, prelude, prefix]
+        end
+
+        def add_to_prelude
+          [tiered_lines, prelude + rendering, prefix]
+        end
+
+        def add_to_lines
+          new_lines = tiered_lines + [
+            Line.new(
+              type: type,
+              indentation_level: indentation_level,
+              value: rendering,
+            ),
+          ]
+          [new_lines, prelude, prefix]
+        end
+
+        def rendering
+          if defined?(@_rendering)
+            @_rendering
+          else
+            @_rendering = node.render(
+              object,
+              preferably_as_lines: true,
+              type: type,
+              indentation_level: indentation_level,
+            )
+          end
+        end
+      end
+
+      class DisallowedNodeError < StandardError
+        def self.create(node_name:)
+          allocate.tap do |error|
+            error.node_name = node_name
+            error.__send__(:initialize)
+          end
+        end
+
+        attr_accessor :node_name
+
+        def initialize(_message = nil)
+          super("#{node_name} is not allowed to be used here!")
+        end
       end
     end
   end

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/inspection_tree_builders/array.rb

@@ -0,0 +1,38 @@
+module SuperDiff
+  module ObjectInspection
+    module InspectionTreeBuilders
+      class Array < Base
+        def self.applies_to?(value)
+          value.is_a?(::Array)
+        end
+
+        def call
+          empty = -> { object.empty? }
+          nonempty = -> { !object.empty? }
+
+          InspectionTree.new do
+            only_when empty do
+              as_lines_when_rendering_to_lines do
+                add_text "[]"
+              end
+            end
+
+            only_when nonempty do
+              as_lines_when_rendering_to_lines(collection_bookend: :open) do
+                add_text "["
+              end
+
+              nested do |array|
+                insert_array_inspection_of(array)
+              end
+
+              as_lines_when_rendering_to_lines(collection_bookend: :close) do
+                add_text "]"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module SuperDiff
+  module ObjectInspection
+    module InspectionTreeBuilders
+      class Base
+        extend AttrExtras.mixin
+        extend ImplementationChecks
+        include ImplementationChecks
+
+        def self.applies_to?(_value)
+          unimplemented_class_method!
+        end
+
+        method_object :object
+
+        def call
+          unimplemented_instance_method!
+        end
+
+        protected
+
+        def inspection_tree
+          unimplemented_instance_method!
+        end
+      end
+    end
+  end
+end