super_diff 0.7.0 → 0.8.0

data/lib/super_diff/equality_matchers/primitive.rb

@@ -2,11 +2,8 @@ module SuperDiff
   module EqualityMatchers
     class Primitive < Base
       def self.applies_to?(value)
-        value.is_a?(Symbol) ||
-          value.is_a?(Numeric) ||
-          # TODO: Test this
-          value == true ||
-          value == false
+        # TODO: Test all of these options
+        SuperDiff.primitive?(value)
       end
 
       def fail
@@ -17,14 +14,14 @@ module SuperDiff
             Helpers.style(
               :expected,
               "Expected: " +
-              SuperDiff.inspect_object(expected, as_single_line: true),
+              SuperDiff.inspect_object(expected, as_lines: false),
             )
           }
           #{
             Helpers.style(
               :actual,
               "  Actual: " +
-              SuperDiff.inspect_object(actual, as_single_line: true),
+              SuperDiff.inspect_object(actual, as_lines: false),
             )
           }
         OUTPUT

data/lib/super_diff/equality_matchers/singleline_string.rb

@@ -13,14 +13,14 @@ module SuperDiff
             Helpers.style(
               :expected,
               "Expected: " +
-              SuperDiff.inspect_object(expected, as_single_line: true),
+              SuperDiff.inspect_object(expected, as_lines: false),
             )
           }
           #{
             Helpers.style(
               :actual,
               "  Actual: " +
-              SuperDiff.inspect_object(actual, as_single_line: true),
+              SuperDiff.inspect_object(actual, as_lines: false),
             )
           }
         OUTPUT

data/lib/super_diff/helpers.rb

@@ -1,7 +1,9 @@
 module SuperDiff
   module Helpers
+    extend self
+
     # TODO: Simplify this
-    def self.style(*args, color_enabled: true, **opts, &block)
+    def style(*args, color_enabled: true, **opts, &block)
       klass =
         if color_enabled && Csi.color_enabled?
           Csi::ColorizedDocument
@@ -20,7 +22,7 @@ module SuperDiff
       document
     end
 
-    def self.plural_type_for(value)
+    def plural_type_for(value)
       case value
       when Numeric then "numbers"
       when String then "strings"
@@ -28,5 +30,53 @@ module SuperDiff
       else "objects"
       end
     end
+
+    def jruby?
+      defined?(JRUBY_VERSION)
+    end
+
+    def ruby_version_matches?(version_string)
+      Gem::Requirement.new(version_string).satisfied_by?(
+        Gem::Version.new(RUBY_VERSION),
+      )
+    end
+
+    if jruby?
+      def object_address_for(object)
+        # Source: <https://github.com/jruby/jruby/blob/master/core/src/main/java/org/jruby/RubyBasicObject.java>
+        "0x%x" % object.hash
+      end
+    elsif ruby_version_matches?(">= 2.7.0")
+      require "json"
+      require "objspace"
+
+      def object_address_for(object)
+        # Sources: <https://bugs.ruby-lang.org/issues/15408> and <https://bugs.ruby-lang.org/issues/15626#Object-ID>
+        address = JSON.parse(ObjectSpace.dump(object))["address"]
+        "0x%016x" % Integer(address, 16)
+      end
+    else
+      def object_address_for(object)
+        "0x%016x" % (object.object_id * 2)
+      end
+    end
+
+    def with_slice_of_array_replaced(array, range, replacement)
+      beginning =
+        if range.begin > 0
+          array[Range.new(0, range.begin - 1)]
+        else
+          []
+        end
+
+      ending =
+        if range.end <= array.length - 1
+          array[Range.new(range.end + 1, array.length - 1)]
+        else
+          []
+        end
+
+      beginning + [replacement] + ending
+    end
   end
 end

data/lib/super_diff/line.rb

@@ -0,0 +1,83 @@
+module SuperDiff
+  class Line
+    extend AttrExtras.mixin
+
+    ICONS = { delete: "-", insert: "+", noop: " " }.freeze
+    COLORS = { insert: :actual, delete: :expected, noop: :plain }.freeze
+
+    rattr_initialize(
+      [
+        :type!,
+        :indentation_level!,
+        :value!,
+        prefix: "",
+        add_comma: false,
+        children: [],
+        elided: false,
+        collection_bookend: nil,
+        complete_bookend: nil,
+      ],
+    )
+    attr_query :add_comma?
+    attr_query :elided?
+
+    def clone_with(overrides = {})
+      self.class.new(
+        type: type,
+        indentation_level: indentation_level,
+        prefix: prefix,
+        value: value,
+        add_comma: add_comma?,
+        children: children,
+        elided: elided?,
+        collection_bookend: collection_bookend,
+        complete_bookend: complete_bookend,
+        **overrides,
+      )
+    end
+
+    def icon
+      ICONS.fetch(type)
+    end
+
+    def color
+      COLORS.fetch(type)
+    end
+
+    def with_comma
+      clone_with(add_comma: true)
+    end
+
+    def as_elided
+      clone_with(elided: true)
+    end
+
+    def with_value_prepended(prelude)
+      clone_with(value: prelude + value)
+    end
+
+    def with_value_appended(suffix)
+      clone_with(value: value + suffix)
+    end
+
+    def prefixed_with(prefix)
+      clone_with(prefix: prefix + self.prefix)
+    end
+
+    def with_complete_bookend(complete_bookend)
+      clone_with(complete_bookend: complete_bookend)
+    end
+
+    def opens_collection?
+      collection_bookend == :open
+    end
+
+    def closes_collection?
+      collection_bookend == :close
+    end
+
+    def complete_bookend?
+      complete_bookend != nil
+    end
+  end
+end

data/lib/super_diff/object_inspection.rb

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