Add support for one-dimensional arrays

Author: mcmire

lib/super_diff/csi.rb

@@ -1,5 +1,6 @@
 require_relative "csi/reset_sequence"
 
+# Source: <https://en.wikipedia.org/wiki/ANSI_escape_code>
 module SuperDiff
   module Csi
     def self.reset_sequence

lib/super_diff/differ.rb

@@ -24,62 +24,127 @@ def call
         ""
       else
         if expected.is_a?(String) && actual.is_a?(String)
-          if expected.include?("\n") || actual.include?("\n")
-            a = expected.split(/\n/).map { |line| "#{line}⏎" }
-            b = actual.split(/\n/).map { |line| "#{line}⏎" }
-            opcodes = sequence_matcher.diff_opcodes(a, b)
-
-            diff = opcodes.flat_map do |code, a_start, a_end, b_start, b_end|
-              if code == :equal
-                b[b_start..b_end].map { |line| normal(" #{line}") }
-              elsif code == :insert
-                b[b_start..b_end].map { |line| inserted("+ #{line}") }
-              else
-                a[a_start..a_end].map { |line| deleted("- #{line}") }
-              end
-            end.join("\n")
-
-            if expected != actual
-              <<~OUTPUT
-                Differing strings.
-
-                Expected: #{expected.inspect}
-                     Got: #{actual.inspect}
-
-                Diff:
-
-                #{diff}
-              OUTPUT
-            else
-              ""
-            end
-          else
-            <<~OUTPUT
-              Differing strings.
+          diff_strings
+        elsif expected.is_a?(Array) && actual.is_a?(Array)
+          diff_arrays
+        else
+          diff_objects
+        end
+      end
+    end
 
-              Expected: #{expected.inspect}
-                   Got: #{actual.inspect}
+    private
 
-              Diff:
+    attr_reader :expected, :actual, :color, :sequence_matcher
 
-              #{deleted("- #{expected}")}
-              #{inserted("+ #{actual}")}
-            OUTPUT
+    def diff_strings
+      if expected.include?("\n") || actual.include?("\n")
+        a = expected.split(/\n/).map { |line| "#{line}⏎" }
+        b = actual.split(/\n/).map { |line| "#{line}⏎" }
+        opcodes = sequence_matcher.diff_opcodes(a, b)
+
+        diff = opcodes.flat_map do |code, a_start, a_end, b_start, b_end|
+          if code == :equal
+            b[b_start..b_end].map { |line| normal(" #{line}") }
+          elsif code == :insert
+            b[b_start..b_end].map { |line| inserted("+ #{line}") }
+          else
+            a[a_start..a_end].map { |line| deleted("- #{line}") }
           end
+        end.join("\n")
+
+        <<~OUTPUT
+          Differing strings.
+
+          Expected: #{expected.inspect}
+            Actual: #{actual.inspect}
+
+          Diff:
+
+          #{diff}
+        OUTPUT
+      else
+        <<~OUTPUT
+          Differing strings.
+
+          Expected: #{expected.inspect}
+            Actual: #{actual.inspect}
+
+          Diff:
+
+          #{deleted("- #{expected}")}
+          #{inserted("+ #{actual}")}
+        OUTPUT
+      end
+    end
+
+    def diff_arrays
+      a, b = expected, actual
+      opcodes = sequence_matcher.diff_opcodes(a, b)
+
+      normalized_opcodes = opcodes.flat_map do |code, a_start, a_end, b_start, b_end|
+        if code == :delete
+          { state: :deleted, index_range: (a_start..a_end), collection: expected }
+        elsif code == :insert
+          { state: :inserted, index_range: (b_start..b_end), collection: actual }
         else
-          <<~OUTPUT
-            Differing objects.
+          { state: :equal, index_range: (b_start..b_end), collection: actual }
+        end
+      end
 
-            Expected: #{expected.inspect}
-                 Got: #{actual.inspect}
-          OUTPUT
+      i = 0
+      details = []
+      while i < normalized_opcodes.length
+        first_event = normalized_opcodes[i]
+        second_event = normalized_opcodes[i + 1]
+        if (
+            first_event[:state] == :deleted &&
+            first_event[:index_range].size == 1 &&
+            second_event &&
+            second_event[:state] == :inserted &&
+            second_event[:index_range].size == 1
+        )
+          index = first_event[:index_range].first
+          details << "- *[#{index}]: Differing #{plural_type_for(actual[index])}.\n" +
+            "  Expected: #{expected[index].inspect}\n" +
+            "    Actual: #{actual[index].inspect}"
+          i += 2
+        else
+          if first_event[:state] == :inserted
+            first_event[:index_range].each do |index|
+              details << "- *[? -> #{index}]: " +
+                "Actual has extra element #{actual[index].inspect}."
+            end
+          elsif first_event[:state] == :deleted
+            first_event[:index_range].each do |index|
+              details << "- *[#{index} -> ?]: " +
+                "Actual is missing element #{expected[index].inspect}."
+            end
+          end
+          i += 1
         end
       end
+
+      <<~OUTPUT
+        Differing arrays.
+
+        Expected: #{expected.inspect}
+          Actual: #{actual.inspect}
+
+        Details:
+
+        #{details.join("\n")}
+      OUTPUT
     end
 
-    private
+    def diff_objects
+      <<~OUTPUT
+        Differing #{plural_type_for(actual)}.
 
-    attr_reader :expected, :actual, :color, :sequence_matcher
+        Expected: #{expected.inspect}
+          Actual: #{actual.inspect}
+      OUTPUT
+    end
 
     def normal(text)
       Csi::ColorHelper.plain(text)
@@ -92,5 +157,13 @@ def inserted(text)
     def deleted(text)
       Csi::ColorHelper.light_red_bg(text)
     end
+
+    def plural_type_for(value)
+      case value
+      when Numeric then "numbers"
+      when String then "strings"
+      else "objects"
+      end
+    end
   end
 end