super_diff 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37e66ee8a26406e1aa13a554cd457192cdfbbe2fc23ce0657875ac15b1d3eb99
-  data.tar.gz: 2bd8e0afbde52a4b3f8735645b0561c988977bdddfed24027dd59026b2b63579
+  metadata.gz: 7cdffdbc9c2efd5ebdfa358abac1e6ce6a425d77bbfa7214cdbfa7ee15ca26f0
+  data.tar.gz: ef20df7cc577a962b2d3ecc6cf64a6b5dff78afef297f0b85ae256b886f4e686
 SHA512:
-  metadata.gz: a2d2b35cbd46653fba718db0c30fe0cea8ea5b5669685b2886f9b74bb8236c3c52d02bb0dc0bb6387654e05ddbe6ee4d7fb4505c797cbff13f093eba5d9c79e9
-  data.tar.gz: 5aa0e9bba24d471de9b04c369b93979cc2d9882326caf80f0654d6c31adbd37ec2bdb2e76a8402f0497bf4c8edaeb380bb24b004fb1d6611596f87f6fcc4349a
+  metadata.gz: 28b06a12e7f183d48087c15355a784db6efc4e07ca0628d259b67bd354e3777f5580d2ee3b02f6c8811146457e362aee6330af9ffa648a23162850d2bb87ec5d
+  data.tar.gz: add9a4eebfc6e65499e528ffab4cfbc25719a7b17053ff040c1a99e5ea7cf4649876341b6e15f68326b950846c3897e2fa4f51747ca68127232d9410eb4a3d72

data/README.md

@@ -92,6 +92,17 @@ you'd get this instead:
 
 [user-docs]: ./docs/users/getting-started.md
 
+### Optional Extensions
+
+If you need diffs for binary strings (`Encoding::ASCII_8BIT`),
+require the binary string integration:
+
+```ruby
+require "super_diff/binary_string"
+```
+
+This enables hex-dump diffs and keeps binary data out of the expectation text.
+
 ## Support
 
 My goal for this library is to improve your development experience.
@@ -113,7 +124,7 @@ for more on how to do that.
 `super_diff` is [tested][gh-actions] to work with
 Ruby >= 3.1,
 RSpec 3.x,
-and Rails >= 6.1.
+and Rails >= 7.0.
 
 [gh-actions]: https://github.com/splitwise/super_diff/actions?query=workflow%3ASuperDiff
 

data/lib/super_diff/basic/operation_tree_builders/multiline_string.rb

@@ -43,6 +43,13 @@ module SuperDiff
 
         attr_reader :sequence_matcher, :original_expected, :original_actual
 
+        # override
+        def should_compare?(_operation, _next_operation)
+          # Don't try to build a nested operation tree for individual line changes, even if
+          # there's an applicable string operation tree builder.
+          false
+        end
+
         def split_into_lines(string)
           string.scan(/.*(?:\r|\n|\r\n|\Z)/)
         end

data/lib/super_diff/binary_string/differs/binary_string.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SuperDiff
+  module BinaryString
+    module Differs
+      class BinaryString < Core::AbstractDiffer
+        def self.applies_to?(expected, actual)
+          SuperDiff::BinaryString.applies_to?(expected, actual)
+        end
+
+        protected
+
+        def operation_tree_builder_class
+          OperationTreeBuilders::BinaryString
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/binary_string/differs.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SuperDiff
+  module BinaryString
+    module Differs
+      autoload(
+        :BinaryString,
+        'super_diff/binary_string/differs/binary_string'
+      )
+    end
+  end
+end

data/lib/super_diff/binary_string/inspection_tree_builders/binary_string.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SuperDiff
+  module BinaryString
+    module InspectionTreeBuilders
+      class BinaryString < Core::AbstractInspectionTreeBuilder
+        def self.applies_to?(value)
+          SuperDiff::BinaryString.applies_to?(value)
+        end
+
+        def call
+          Core::InspectionTree.new do |t|
+            t.add_text "<binary string (#{object.bytesize} bytes)>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/binary_string/inspection_tree_builders.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SuperDiff
+  module BinaryString
+    module InspectionTreeBuilders
+      autoload(
+        :BinaryString,
+        'super_diff/binary_string/inspection_tree_builders/binary_string'
+      )
+    end
+  end
+end

data/lib/super_diff/binary_string/operation_tree_builders/binary_string.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module SuperDiff
+  module BinaryString
+    module OperationTreeBuilders
+      class BinaryString < Basic::OperationTreeBuilders::MultilineString
+        BYTES_PER_LINE = 16
+        private_constant :BYTES_PER_LINE
+
+        def self.applies_to?(expected, actual)
+          SuperDiff::BinaryString.applies_to?(expected, actual)
+        end
+
+        def initialize(*args)
+          args.first[:expected] = binary_to_hex(args.first[:expected])
+          args.first[:actual] = binary_to_hex(args.first[:actual])
+
+          super
+        end
+
+        protected
+
+        def build_operation_tree
+          OperationTrees::BinaryString.new([])
+        end
+
+        private
+
+        def split_into_lines(string)
+          super.map { |line| line.delete_suffix("\n") }.reject(&:empty?)
+        end
+
+        def binary_to_hex(data)
+          data
+            .each_byte
+            .each_slice(BYTES_PER_LINE)
+            .with_index
+            .map { |bytes, index| format_hex_line(index * BYTES_PER_LINE, bytes) }
+            .join("\n")
+        end
+
+        def format_hex_line(offset, bytes)
+          hex_pairs = bytes
+                      .map { |b| format('%02x', b) }
+                      .each_slice(2)
+                      .map(&:join)
+                      .join(' ')
+
+          ascii = bytes.map { |b| printable_char(b) }.join
+
+          format('%<offset>08x: %<hex>-39s  %<ascii>s', offset:, hex: hex_pairs, ascii:)
+        end
+
+        def printable_char(byte)
+          byte >= 32 && byte < 127 ? byte.chr : '.'
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/binary_string/operation_tree_builders.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SuperDiff
+  module BinaryString
+    module OperationTreeBuilders
+      autoload(
+        :BinaryString,
+        'super_diff/binary_string/operation_tree_builders/binary_string'
+      )
+    end
+  end
+end

data/lib/super_diff/binary_string/operation_tree_flatteners/binary_string.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SuperDiff
+  module BinaryString
+    module OperationTreeFlatteners
+      class BinaryString < Core::AbstractOperationTreeFlattener
+        def build_tiered_lines
+          operation_tree.map do |operation|
+            Core::Line.new(
+              type: operation.name,
+              indentation_level: indentation_level,
+              value: operation.value
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/binary_string/operation_tree_flatteners.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SuperDiff
+  module BinaryString
+    module OperationTreeFlatteners
+      autoload(
+        :BinaryString,
+        'super_diff/binary_string/operation_tree_flatteners/binary_string'
+      )
+    end
+  end
+end

data/lib/super_diff/binary_string/operation_trees/binary_string.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SuperDiff
+  module BinaryString
+    module OperationTrees
+      class BinaryString < Core::AbstractOperationTree
+        def self.applies_to?(value)
+          SuperDiff::BinaryString.applies_to?(value)
+        end
+
+        protected
+
+        def operation_tree_flattener_class
+          OperationTreeFlatteners::BinaryString
+        end
+      end
+    end
+  end
+end

data/lib/super_diff/binary_string/operation_trees.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SuperDiff
+  module BinaryString
+    module OperationTrees
+      autoload(
+        :BinaryString,
+        'super_diff/binary_string/operation_trees/binary_string'
+      )
+    end
+  end
+end

data/lib/super_diff/binary_string.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'super_diff/binary_string/differs'
+require 'super_diff/binary_string/inspection_tree_builders'
+require 'super_diff/binary_string/operation_trees'
+require 'super_diff/binary_string/operation_tree_builders'
+require 'super_diff/binary_string/operation_tree_flatteners'
+
+module SuperDiff
+  module BinaryString
+    def self.applies_to?(*values)
+      values.all? { |value| value.is_a?(::String) && value.encoding == Encoding::ASCII_8BIT }
+    end
+
+    SuperDiff.configure do |config|
+      config.prepend_extra_differ_classes(Differs::BinaryString)
+      config.prepend_extra_inspection_tree_builder_classes(
+        InspectionTreeBuilders::BinaryString
+      )
+    end
+  end
+end

data/lib/super_diff/core/tiered_lines_elider.rb

@@ -41,16 +41,7 @@ module SuperDiff
 
       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) }
-          )
+          BuildPanes.call(dirty_panes: dirty_panes, lines: lines)
       end
 
       def dirty_panes
@@ -109,8 +100,8 @@ module SuperDiff
 
       def all_indentation_levels
         lines
+          .reject(&:complete_bookend?)
           .map(&:indentation_level)
-          .select(&:positive?)
           .uniq
       end
 
@@ -140,19 +131,15 @@ module SuperDiff
       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))
+        ).map(&method(:combine_contiguous_boxes))
       end
 
       def box_groups_at_decreasing_indentation_levels_within(pane)
         boxes_within_pane = boxes.select { |box| box.fits_fully_within?(pane) }
 
-        possible_indentation_levels =
-          boxes_within_pane
-          .map(&:indentation_level)
-          .select(&:positive?)
-          .uniq
-          .sort
-          .reverse
+        levels = boxes_within_pane.map(&:indentation_level).uniq
+
+        possible_indentation_levels = levels.sort.reverse
 
         possible_indentation_levels.map do |indentation_level|
           boxes_within_pane.select do |box|
@@ -162,26 +149,29 @@ module SuperDiff
       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
+        # First, sorts boxes by beginning ascending, range descending. (Boxes may
+        # never share beginnings, so the latter may be useless, but this is at least
+        # sufficient if unnecessary.)
+        #
+        # Then, iterate through each box, keeping track of the farthest "end" of any
+        # box seen so far. If the current box we are on ends before (or on) that farthest
+        # end, we know there is some box earlier in the sequence that begins <= this one
+        # (because of the prior sorting), and ends >= this one; that is, the current box
+        # is fully contained, and we can filter it out.
+        sorted = boxes.sort_by { |box| [box.range.begin, -box.range.end] }
+        max_end = -1
+
+        sorted.reject do |box|
+          contained = box.range.end <= max_end
+          max_end = box.range.end if box.range.end > max_end
+          contained
         end
       end
 
-      def combine_congruent_boxes(boxes)
+      def combine_contiguous_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|
@@ -347,19 +337,6 @@ module SuperDiff
         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].max
-          new_ending = [range.end, ending].min
-          self.class.new(
-            type: type,
-            range: Range.new(new_beginning, new_ending)
-          )
-        end
       end
 
       class BuildBoxes

data/lib/super_diff/rspec/differ.rb

@@ -42,10 +42,16 @@ module SuperDiff
       end
 
       def comparing_singleline_strings?
+        return false if comparing_binary_strings?
+
         expected.is_a?(String) && actual.is_a?(String) &&
           !expected.include?("\n") && !actual.include?("\n")
       end
 
+      def comparing_binary_strings?
+        defined?(BinaryString) && BinaryString.applies_to?(expected, actual)
+      end
+
       def helpers
         @helpers ||= RSpecHelpers.new
       end

data/lib/super_diff/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SuperDiff
-  VERSION = '0.18.0'
+  VERSION = '0.19.0'
 end

data/super_diff.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |s|
   s.files = %w[README.md super_diff.gemspec] + Dir['lib/**/*']
   s.executables = Dir['exe/**/*'].map { |f| File.basename(f) }
 
-  s.add_dependency 'attr_extras', '>= 6.2.4'
-  s.add_dependency 'diff-lcs'
-  s.add_dependency 'patience_diff'
+  s.add_dependency 'attr_extras', '>= 6.2.4', '< 8'
+  s.add_dependency 'diff-lcs', '~> 1.5'
+  s.add_dependency 'patience_diff', '~> 1.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: super_diff
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Elliot Winkler
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-05 00:00:00.000000000 Z
+date: 2026-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: attr_extras
@@ -18,6 +18,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.2.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -25,34 +28,37 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.2.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
 - !ruby/object:Gem::Dependency
   name: diff-lcs
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: patience_diff
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.2'
 description: |
   SuperDiff is a gem that hooks into RSpec to intelligently display the
   differences between two data structures of any type.
@@ -139,6 +145,17 @@ files:
 - lib/super_diff/basic/operation_trees/default_object.rb
 - lib/super_diff/basic/operation_trees/hash.rb
 - lib/super_diff/basic/operation_trees/multiline_string.rb
+- lib/super_diff/binary_string.rb
+- lib/super_diff/binary_string/differs.rb
+- lib/super_diff/binary_string/differs/binary_string.rb
+- lib/super_diff/binary_string/inspection_tree_builders.rb
+- lib/super_diff/binary_string/inspection_tree_builders/binary_string.rb
+- lib/super_diff/binary_string/operation_tree_builders.rb
+- lib/super_diff/binary_string/operation_tree_builders/binary_string.rb
+- lib/super_diff/binary_string/operation_tree_flatteners.rb
+- lib/super_diff/binary_string/operation_tree_flatteners/binary_string.rb
+- lib/super_diff/binary_string/operation_trees.rb
+- lib/super_diff/binary_string/operation_trees/binary_string.rb
 - lib/super_diff/core.rb
 - lib/super_diff/core/abstract_differ.rb
 - lib/super_diff/core/abstract_inspection_tree_builder.rb