super_diff 0.7.0 → 0.8.0

data/lib/super_diff/rspec/object_inspection/{inspectors → inspection_tree_builders}/kind_of.rb

@@ -1,15 +1,13 @@
 module SuperDiff
   module RSpec
     module ObjectInspection
-      module Inspectors
-        class KindOf < SuperDiff::ObjectInspection::Inspectors::Base
+      module InspectionTreeBuilders
+        class KindOf < SuperDiff::ObjectInspection::InspectionTreeBuilders::Base
           def self.applies_to?(value)
             SuperDiff::RSpec.a_kind_of_something?(value) || SuperDiff::RSpec.kind_of_something?(value)
           end
 
-          protected
-
-          def inspection_tree
+          def call
             SuperDiff::ObjectInspection::InspectionTree.new do
               add_text do |value|
                 klass = if SuperDiff::RSpec.a_kind_of_something?(value)

data/lib/super_diff/rspec/object_inspection/{inspectors → inspection_tree_builders}/object_having_attributes.rb

@@ -1,27 +1,25 @@
 module SuperDiff
   module RSpec
     module ObjectInspection
-      module Inspectors
-        class ObjectHavingAttributes < SuperDiff::ObjectInspection::Inspectors::Base
+      module InspectionTreeBuilders
+        class ObjectHavingAttributes < SuperDiff::ObjectInspection::InspectionTreeBuilders::Base
           def self.applies_to?(value)
             SuperDiff::RSpec.an_object_having_some_attributes?(value)
           end
 
-          protected
-
-          def inspection_tree
+          def call
             SuperDiff::ObjectInspection::InspectionTree.new do
-              add_text "#<an object having attributes ("
+              as_lines_when_rendering_to_lines(collection_bookend: :open) do
+                add_text "#<an object having attributes ("
+              end
 
               nested do |aliased_matcher|
-                insert_hash_inspection_of(
-                  aliased_matcher.expected,
-                  initial_break: nil,
-                )
+                insert_hash_inspection_of(aliased_matcher.expected)
               end
 
-              add_break
-              add_text ")>"
+              as_lines_when_rendering_to_lines(collection_bookend: :close) do
+                add_text ")>"
+              end
             end
           end
         end

data/lib/super_diff/rspec/object_inspection/inspection_tree_builders/primitive.rb

@@ -0,0 +1,10 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module InspectionTreeBuilders
+        class Primitive < SuperDiff::ObjectInspection::InspectionTreeBuilders::Primitive
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/object_inspection/inspection_tree_builders/value_within.rb

@@ -0,0 +1,33 @@
+module SuperDiff
+  module RSpec
+    module ObjectInspection
+      module InspectionTreeBuilders
+        class ValueWithin < SuperDiff::ObjectInspection::InspectionTreeBuilders::Base
+          def self.applies_to?(value)
+            SuperDiff::RSpec.a_value_within_something?(value)
+          end
+
+          def call
+            SuperDiff::ObjectInspection::InspectionTree.new do
+              as_prelude_when_rendering_to_lines do
+                add_text "#<a value within "
+
+                add_inspection_of as_lines: false do |aliased_matcher|
+                  aliased_matcher.base_matcher.instance_variable_get("@delta")
+                end
+
+                add_text " of "
+              end
+
+              # rubocop:disable Style/SymbolProc
+              add_inspection_of { |aliased_matcher| aliased_matcher.expected }
+              # rubocop:enable Style/SymbolProc
+
+              add_text ">"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/rspec/operation_tree_builders/collection_containing_exactly.rb

@@ -52,7 +52,6 @@ module SuperDiff
             key: index,
             value: value,
             index: index,
-            index_in_collection: collection.index(value),
           )
         end
 
@@ -64,7 +63,6 @@ module SuperDiff
             key: index,
             value: value,
             index: index,
-            index_in_collection: collection.index(value),
           )
         end
 
@@ -76,7 +74,6 @@ module SuperDiff
             key: index,
             value: value,
             index: index,
-            index_in_collection: collection.index(value),
           )
         end
 

data/lib/super_diff/tiered_lines.rb

@@ -0,0 +1,4 @@
+module SuperDiff
+  class TieredLines < Array
+  end
+end

data/lib/super_diff/tiered_lines_elider.rb

@@ -0,0 +1,490 @@
+module SuperDiff
+  class TieredLinesElider
+    SIZE_OF_ELISION = 1
+
+    extend AttrExtras.mixin
+    include Helpers
+
+    method_object :lines
+
+    def call
+      if all_lines_are_changed_or_unchanged?
+        lines
+      else
+        elided_lines
+      end
+    end
+
+    private
+
+    def all_lines_are_changed_or_unchanged?
+      panes.size == 1 && panes.first.range == Range.new(0, lines.length - 1)
+    end
+
+    def elided_lines
+      boxes_to_elide.reverse.reduce(lines) do |lines_with_elisions, box|
+        with_box_elided(box, lines_with_elisions)
+      end
+    end
+
+    def boxes_to_elide
+      @_boxes_to_elide ||=
+        panes_to_consider_for_eliding.reduce([]) do |array, pane|
+          array + (find_boxes_to_elide_within(pane) || [])
+        end
+    end
+
+    def panes_to_consider_for_eliding
+      panes.select do |pane|
+        pane.type == :clean && pane.range.size > maximum
+      end
+    end
+
+    def panes
+      @_panes ||= BuildPanes.call(dirty_panes: padded_dirty_panes, lines: lines)
+    end
+
+    def padded_dirty_panes
+      @_padded_dirty_panes ||= combine_congruent_panes(
+        dirty_panes.
+        map(&:padded).
+        map { |pane| pane.capped_to(0, lines.size - 1) }
+      )
+    end
+
+    def dirty_panes
+      @_dirty_panes ||= lines.
+        each_with_index.
+        select { |line, index| line.type != :noop }.
+        reduce([]) do |panes, (_, index)|
+          if !panes.empty? && panes.last.range.end == index - 1
+            panes[0..-2] + [panes[-1].extended_to(index)]
+          else
+            panes + [Pane.new(type: :dirty, range: index..index)]
+          end
+        end
+    end
+
+    def with_box_elided(box, lines)
+      box_at_start_of_lines =
+        if lines.first.complete_bookend?
+          box.range.begin == 1
+        else
+          box.range.begin == 0
+        end
+
+      box_at_end_of_lines =
+        if lines.last.complete_bookend?
+          box.range.end == lines.size - 2
+        else
+          box.range.end == lines.size - 1
+        end
+
+      if one_dimensional_line_tree? && outermost_box?(box)
+        if box_at_start_of_lines
+          with_start_of_box_elided(box, lines)
+        elsif box_at_end_of_lines
+          with_end_of_box_elided(box, lines)
+        else
+          with_middle_of_box_elided(box, lines)
+        end
+      else
+        with_subset_of_lines_elided(
+          lines,
+          range: box.range,
+          indentation_level: box.indentation_level,
+        )
+      end
+    end
+
+    def outermost_box?(box)
+      box.indentation_level == all_indentation_levels.min
+    end
+
+    def one_dimensional_line_tree?
+      all_indentation_levels.size == 1
+    end
+
+    def all_indentation_levels
+      lines.
+        map(&:indentation_level).
+        select { |indentation_level| indentation_level > 0 }.
+        uniq
+    end
+
+    def find_boxes_to_elide_within(pane)
+      set_of_boxes =
+        normalized_box_groups_at_decreasing_indentation_levels_within(pane)
+
+      total_size_before_eliding = lines[pane.range].
+        reject(&:complete_bookend?).
+        size
+
+      if total_size_before_eliding > maximum
+        if maximum > 0
+          set_of_boxes.find do |boxes|
+            total_size_after_eliding =
+              total_size_before_eliding -
+              boxes.sum { |box| box.range.size - SIZE_OF_ELISION }
+            total_size_after_eliding <= maximum
+          end
+        else
+          set_of_boxes[-1]
+        end
+      else
+        []
+      end
+    end
+
+    def normalized_box_groups_at_decreasing_indentation_levels_within(pane)
+      box_groups_at_decreasing_indentation_levels_within(pane).
+        map(&method(:filter_out_boxes_fully_contained_in_others)).
+        map(&method(:combine_congruent_boxes))
+    end
+
+    def box_groups_at_decreasing_indentation_levels_within(pane)
+      boxes_within_pane = boxes.select do |box|
+        box.fits_fully_within?(pane)
+      end
+
+      possible_indentation_levels = boxes_within_pane.
+        map(&:indentation_level).
+        select { |indentation_level| indentation_level > 0 }.
+        uniq.
+        sort.
+        reverse
+
+      possible_indentation_levels.map do |indentation_level|
+        boxes_within_pane.select do |box|
+          box.indentation_level >= indentation_level
+        end
+      end
+    end
+
+    def filter_out_boxes_fully_contained_in_others(boxes)
+      sorted_boxes = boxes.sort_by do |box|
+        [box.indentation_level, box.range.begin, box.range.end]
+      end
+
+      boxes.reject do |box2|
+        sorted_boxes.any? do |box1|
+          !box1.equal?(box2) && box1.fully_contains?(box2)
+        end
+      end
+    end
+
+    def combine_congruent_boxes(boxes)
+      combine(boxes, on: :indentation_level)
+    end
+
+    def combine_congruent_panes(panes)
+      combine(panes, on: :type)
+    end
+
+    def combine(spannables, on:)
+      criterion = on
+      spannables.reduce([]) do |combined_spannables, spannable|
+        if (
+          !combined_spannables.empty? &&
+          spannable.range.begin <= combined_spannables.last.range.end + 1 &&
+          spannable.public_send(criterion) ==
+            combined_spannables.last.public_send(criterion)
+        )
+          combined_spannables[0..-2] + [
+            combined_spannables[-1].extended_to(spannable.range.end),
+          ]
+        else
+          combined_spannables + [spannable]
+        end
+      end
+    end
+
+    def boxes
+      @_boxes ||= BuildBoxes.call(lines)
+    end
+
+    def with_start_of_box_elided(box, lines)
+      amount_to_elide =
+        if maximum > 0
+          box.range.size - maximum + SIZE_OF_ELISION
+        else
+          box.range.size
+        end
+
+      with_subset_of_lines_elided(
+        lines,
+        range: Range.new(
+          box.range.begin,
+          box.range.begin + amount_to_elide - 1,
+        ),
+        indentation_level: box.indentation_level
+      )
+    end
+
+    def with_end_of_box_elided(box, lines)
+      amount_to_elide =
+        if maximum > 0
+          box.range.size - maximum + SIZE_OF_ELISION
+        else
+          box.range.size
+        end
+
+      range =
+        if amount_to_elide > 0
+          Range.new(box.range.end - amount_to_elide + 1, box.range.end)
+        else
+          box.range
+        end
+
+      with_subset_of_lines_elided(
+        lines,
+        range: range,
+        indentation_level: box.indentation_level
+      )
+    end
+
+    def with_middle_of_box_elided(box, lines)
+      half_of_maximum, remainder =
+        if maximum > 0
+          (maximum - SIZE_OF_ELISION).divmod(2)
+        else
+          [0, 0]
+        end
+
+      opening_length, closing_length =
+        half_of_maximum, half_of_maximum + remainder
+
+      with_subset_of_lines_elided(
+        lines,
+        range: Range.new(
+          box.range.begin + opening_length,
+          box.range.end - closing_length,
+        ),
+        indentation_level: box.indentation_level
+      )
+    end
+
+    def with_subset_of_lines_elided(lines, range:, indentation_level:)
+      with_slice_of_array_replaced(
+        lines,
+        range,
+        Elision.new(
+          indentation_level: indentation_level,
+          children: lines[range].map(&:as_elided),
+        ),
+      )
+    end
+
+    def maximum
+      SuperDiff.configuration.diff_elision_maximum || 0
+    end
+
+    class BuildPanes
+      extend AttrExtras.mixin
+
+      method_object [:dirty_panes!, :lines!]
+
+      def call
+        beginning + middle + ending
+      end
+
+      private
+
+      def beginning
+        if (
+          dirty_panes.empty? ||
+          dirty_panes.first.range.begin == 0
+        )
+          []
+        else
+          [
+            Pane.new(
+              type: :clean,
+              range: Range.new(
+                0,
+                dirty_panes.first.range.begin - 1
+              )
+            )
+          ]
+        end
+      end
+
+      def middle
+        if dirty_panes.size == 1
+          dirty_panes
+        else
+          dirty_panes.
+            each_with_index.
+            each_cons(2).
+            reduce([]) do |panes, ((pane1, _), (pane2, index2))|
+              panes +
+              [
+                pane1,
+                Pane.new(
+                  type: :clean,
+                  range: Range.new(
+                    pane1.range.end + 1,
+                    pane2.range.begin - 1,
+                  )
+                )
+              ] + (
+                index2 == dirty_panes.size - 1 ?
+                [pane2] :
+                []
+              )
+            end
+        end
+      end
+
+      def ending
+        if (
+          dirty_panes.empty? ||
+          dirty_panes.last.range.end >= lines.size - 1
+        )
+          []
+        else
+          [
+            Pane.new(
+              type: :clean,
+              range: Range.new(
+                dirty_panes.last.range.end + 1,
+                lines.size - 1
+              )
+            )
+          ]
+        end
+      end
+    end
+
+    class Pane
+      extend AttrExtras.mixin
+
+      rattr_initialize [:type!, :range!]
+
+      def extended_to(new_end)
+        self.class.new(type: type, range: range.begin..new_end)
+      end
+
+      def padded
+        self.class.new(
+          type: type,
+          range: Range.new(range.begin, range.end)
+        )
+      end
+
+      def capped_to(beginning, ending)
+        new_beginning = range.begin < beginning ? beginning : range.begin
+        new_ending = range.end > ending ? ending : range.end
+        self.class.new(
+          type: type,
+          range: Range.new(new_beginning, new_ending),
+        )
+      end
+    end
+
+    class BuildBoxes
+      def self.call(lines)
+        builder = new(lines)
+        builder.build
+        builder.final_boxes
+      end
+
+      attr_reader :final_boxes
+
+      def initialize(lines)
+        @lines = lines
+
+        @open_collection_boxes = []
+        @final_boxes = []
+      end
+
+      def build
+        lines.each_with_index do |line, index|
+          if line.opens_collection?
+            open_new_collection_box(line, index)
+          elsif line.closes_collection?
+            extend_working_collection_box(index)
+            close_working_collection_box
+          else
+            extend_working_collection_box(index) if open_collection_boxes.any?
+            record_item_box(line, index)
+          end
+        end
+      end
+
+      private
+
+      attr_reader :lines, :open_collection_boxes
+
+      def extend_working_collection_box(index)
+        open_collection_boxes.last.extend_to(index)
+      end
+
+      def close_working_collection_box
+        final_boxes << open_collection_boxes.pop
+      end
+
+      def open_new_collection_box(line, index)
+        open_collection_boxes << Box.new(
+          indentation_level: line.indentation_level,
+          range: index..index,
+        )
+      end
+
+      def record_item_box(line, index)
+        final_boxes << Box.new(
+          indentation_level: line.indentation_level,
+          range: index..index,
+        )
+      end
+    end
+
+    class Box
+      extend AttrExtras.mixin
+
+      rattr_initialize [:indentation_level!, :range!]
+
+      def fully_contains?(other)
+        range.begin <= other.range.begin && range.end >= other.range.end
+      end
+
+      def fits_fully_within?(other)
+        other.range.begin <= range.begin && other.range.end >= range.end
+      end
+
+      def extended_to(new_end)
+        dup.tap { |clone| clone.extend_to(new_end) }
+      end
+
+      def extend_to(new_end)
+        @range = range.begin..new_end
+      end
+    end
+
+    class Elision
+      extend AttrExtras.mixin
+
+      rattr_initialize [:indentation_level!, :children!]
+
+      def type
+        :elision
+      end
+
+      def prefix
+        ""
+      end
+
+      def value
+        "# ..."
+      end
+
+      def elided?
+        true
+      end
+
+      def add_comma?
+        false
+      end
+    end
+  end
+end