lib/minitest/compress.rb in minitest-5.24.1 vs lib/minitest/compress.rb in minitest-5.25.0

@@ -9,16 +9,16 @@
     # cycles in it to make it more readable.
 
     def compress orig
       ary = orig
 
-      eswo = ->(ary, n, off) { # each_slice_with_offset
+      eswo = ->(a, n, off) { # each_slice_with_offset
         if off.zero? then
-          ary.each_slice n
+          a.each_slice n
         else
           # [ ...off... [...n...] [...n...] ... ]
-          front, back = ary.take(off), ary.drop(off)
+          front, back = a.take(off), a.drop(off)
           [front].chain back.each_slice n
         end
       }
 
       3.times do # maybe don't use loop do here?
@@ -27,20 +27,20 @@
           .times                                  # 0...size
           .group_by { |i| ary[i] }                # { a: [0] b: [1 3 5], c: [2 4 6], d: [7] }
 
         order = index
           .reject { |k, v| v.size == 1 }          # { b: [1 3 5], c: [2 4 6] }
-          .sort_by { |k, ary|                     ### sort by max dist + min offset
-            d = ary.each_cons(2).sum { |a, b| b-a }
-            [-d, ary.first]
+          .sort_by { |k, a1|                      ### sort by max dist + min offset
+            d = a1.each_cons(2).sum { |a2, b| b-a2 }
+            [-d, a1.first]
           }                                       # b: [1 3 5] c: [2 4 6]
 
         ranges = order
-          .map { |k, ary|                         # [[1..2 3..4] [2..3 4..5]]
-            ary
+          .map { |k, a1|                          # [[1..2 3..4] [2..3 4..5]]
+            a1
               .each_cons(2)
-              .map { |a, b| a..b-1 }
+              .map { |a2, b| a2..b-1 }
           }
 
         big_ranges = ranges
           .flat_map { |a|                         # [1..2 3..4 2..3 4..5]
             a.sort_by { |r| [-r.size, r.first] }.first 5
@@ -48,10 +48,10 @@
           .first(100)
 
         culprits = big_ranges
           .map { |r|
             eswo[ary, r.size, r.begin]            # [o1 s1 s1 s2 s2]
-              .chunk_while { |a,b| a == b }       # [[o1] [s1 s1] [s2 s2]]
+              .chunk_while { |a, b| a == b }      # [[o1] [s1 s1] [s2 s2]]
               .map { |a| [a.size, a.first] }      # [[1 o1] [2 s1] [2 s2]]
           }
           .select { |chunks|
             chunks.any? { |a| a.first > 1 }       # compressed anything?
           }