Fix test failures: Range precedence, step, to_ranges, occurrence

- Fix Range assertion tests: wrap range literals in parens to avoid
  operator precedence issues with assert ==
- Fix Array#step tests for new 0-based offset behavior
- Fix Array#to_ranges to always return Range objects (not bare values)
- Update arrange/rangify tests to expect single-element ranges
- Undeprecate Array#occurrence (block form is unique vs tally)
- Fix Range#+ tests for new to_ranges behavior

Test results: 1270 tests, 1215 passing, 36 errors, 5 failures, 14 pending

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: trans

lib/core/facets/array/occurrence.rb

@@ -11,10 +11,22 @@ class Array
   #   [2,2,3,4,4,4].occurrence{|i| i % 2}
   #   #=> { 0 => 5, 1 => 1 }
   #
-  def occurrence(&block)
-    warn "Array#occurrence is deprecated. Use Array#tally instead.", uplevel: 1
-    tally(&block)
+  # Without a block, this is equivalent to Ruby's #tally.
+  # With a block, the block transforms the key before counting,
+  # which #tally does not support.
+  #
+  def occurrence
+    h = Hash.new(0)
+    if block_given?
+      each do |e|
+        h[yield(e)] += 1
+      end
+    else
+      each do |e|
+        h[e] += 1
+      end
+    end
+    h
   end
 
 end
-

lib/core/facets/array/to_ranges.rb

@@ -2,12 +2,13 @@ class Array
 
   # Produces an array of ranges from the values in the array.
   # Contiguous values and overlapping ranges are merged.
+  # Single values are returned as single-element ranges (e.g. 1..1).
   #
   # Examples
   #
   #     [1,2,3,6,7,8].to_ranges  #=> [1..3, 6..8]
   #
-  #     [3,4,5,1,6,9,8].to_ranges  #=> [1..6, 8..9]
+  #     [3,4,5,1,6,9,8].to_ranges  #=> [1..1, 3..6, 8..9]
   #
   #     [10..15, 16..20, 21, 22].to_ranges  #=> [10..22]
   #
@@ -20,7 +21,7 @@ class Array
 
   def to_ranges
     array = compact.uniq.sort_by { |e| Range === e ? e.first : e }
-    array.inject([]) do |c, value|
+    result = array.inject([]) do |c, value|
       unless c.empty?
         last = c.last
         last_value    = (Range === last  ? last.last   : last)
@@ -37,6 +38,8 @@ def to_ranges
         c << value
       end
     end
+    # Ensure all elements are ranges
+    result.map { |e| Range === e ? e : e..e }
   end
 
   alias arrange to_ranges

test/core/array/test_arrange.rb

@@ -4,33 +4,33 @@
 
 	method :rangify do
 		test 'Array of consecutive integers should return an array made up of a single range.' do
-			[1,2,3,4,5].rangify.assert == [1..5]
+			[1,2,3,4,5].rangify.assert == ([1..5])
 		end
-		
-		test 'Array of non-consecutive integers should return the original array.' do
-			[1,3,5,7].rangify.assert == [1,3,5,7]
+
+		test 'Array of non-consecutive integers should return single-element ranges.' do
+			[1,3,5,7].rangify.assert == ([1..1, 3..3, 5..5, 7..7])
 		end
 
 		test 'Array of ranges should return the correct ranges.' do
 			arr = [40..45, 1..3, 4..10, 20..30, 24..28, 42..50, 1..6, 1..3, 1..1]
-			arr.rangify.assert == [1..10, 20..30, 40..50]
+			arr.rangify.assert == ([1..10, 20..30, 40..50])
 		end
-		
+
 		test 'Array of ranges and integers should return the correct ranges.' do
 			arr = [99, 100, 1..3, 101, 4..5, 103, 10..19, 99, 20..20, 31, 32..33, 98, 97]
-			arr.rangify.assert == [1..5, 10..20, 31..33, 97..101, 103]
-		end	
+			arr.rangify.assert == ([1..5, 10..20, 31..33, 97..101, 103..103])
+		end
 
 		test 'Array of non-consecutive integers should return the correct ranges.' do
-			[1,2,3,6,7,8,10,15].rangify.assert == [1..3, 6..8, 10, 15] 
+			[1,2,3,6,7,8,10,15].rangify.assert == ([1..3, 6..8, 10..10, 15..15])
 		end
-	
+
 		test 'Element order should not affect the result.' do
-			[8, 1, 15, 2, 6, 3, 7, 10].rangify.assert == [1..3, 6..8, 10, 15] 
+			[8, 1, 15, 2, 6, 3, 7, 10].rangify.assert == ([1..3, 6..8, 10..10, 15..15])
 		end
-		
+
 		test 'Duplicate elements should not affect the result.' do
-			[8, 1, 15, 2, 6, 3, 7, 10, 8, 15, 2, 3, 1, 2].rangify.assert == [1..3, 6..8, 10, 15] 
+			[8, 1, 15, 2, 6, 3, 7, 10, 8, 15, 2, 3, 1, 2].rangify.assert == ([1..3, 6..8, 10..10, 15..15])
 		end
 	end
 

test/core/array/test_step.rb

@@ -10,19 +10,22 @@
 
       a.step(2){ |e| r << e }
 
-      r.assert == [:b, :d]
+      r.assert == [:a, :c]
     end
 
     test "conversion to array" do
       a = [:a, :b, :c, :d]
       a.step(1).to_a.assert == [:a, :b, :c, :d]
-      a.step(2).to_a.assert == [:b, :d]
-      a.step(3).to_a.assert == [:c]
-      a.step(5).to_a.assert == []
+      a.step(2).to_a.assert == [:a, :c]
+      a.step(3).to_a.assert == [:a, :d]
+      a.step(5).to_a.assert == [:a]
+    end
+
+    test "with offset" do
+      a = [:a, :b, :c, :d, :e, :f]
+      a.step(2, 1).to_a.assert == [:b, :d, :f]
     end
 
   end
 
 end
-
-

test/core/array/test_to_ranges.rb

@@ -5,15 +5,15 @@
   method :to_ranges do
 
     test "flat values" do
-      [3,4,5,1,6,9,8].to_ranges.assert == [1..1, 3..6, 8..9]
+      [3,4,5,1,6,9,8].to_ranges.assert == ([1..1, 3..6, 8..9])
     end
 
     test "consecutive" do
-      [1,2,3,4,5].to_ranges.assert == [1..5]
+      [1,2,3,4,5].to_ranges.assert == ([1..5])
     end
 
     test "mixed ranges and values" do
-      [10..15, 16..20, 21, 22].to_ranges.assert == [10..22]
+      [10..15, 16..20, 21, 22].to_ranges.assert == ([10..22])
     end
 
   end

test/core/range/test_intersection.rb

@@ -5,39 +5,39 @@
   class_method :intersection do
 
     test "two overlapping ranges" do
-      Range.intersection(1..10, 5..15).assert == 5..10
+      Range.intersection(1..10, 5..15).assert == (5..10)
     end
 
     test "three overlapping ranges" do
-      Range.intersection(1..5, 3..7, 4..9).assert == 4..5
+      Range.intersection(1..5, 3..7, 4..9).assert == (4..5)
     end
 
     test "non-overlapping ranges" do
       Range.intersection(1..3, 5..7).assert == nil
     end
 
     test "floats" do
-      Range.intersection(1.0..5.0, 2.5..4.5).assert == 2.5..4.5
+      Range.intersection(1.0..5.0, 2.5..4.5).assert == (2.5..4.5)
     end
 
     test "identical ranges" do
-      Range.intersection(1..5, 1..5).assert == 1..5
+      Range.intersection(1..5, 1..5).assert == (1..5)
     end
 
     test "one range contains the other" do
-      Range.intersection(1..10, 3..5).assert == 3..5
+      Range.intersection(1..10, 3..5).assert == (3..5)
     end
 
   end
 
   method :intersection do
 
     test "instance method" do
-      (1..10).intersection(5..15).assert == 5..10
+      (1..10).intersection(5..15).assert == (5..10)
     end
 
     test "multiple arguments" do
-      (1..10).intersection(5..15, 8..20).assert == 8..10
+      (1..10).intersection(5..15, 8..20).assert == (8..10)
     end
 
   end

test/core/range/test_op_add.rb

@@ -6,14 +6,14 @@
     #test { lambda{ (1..10) + 'a' }.assert raise_error }
 
     test { ((1..10) + (11..11)).assert == [1..11] }
-    test { ((1..10) + 12).assert == [1..10, 12] }
+    test { ((1..10) + 12).assert == ([1..10, 12..12]) }
     test { ((1..10) + (10..12)).assert == [1..12] }
     test { ((1..10) + (11..12)).assert == [1..12] }
     test { ((1..10) + (9..12)).assert == [1..12] }
     test { ((1..10) + (1..12)).assert == [1..12] }
     test { ((1..10) + (12..20)).assert == [1..10, 12..20] }
     test { ((1..10) + 0).assert == [0..10] }
-    test { ((1..10) + -1).assert == [-1, 1..10] }
+    test { ((1..10) + -1).assert == ([-1..-1, 1..10]) }
     test { ((1..10) + (-10..-1)).assert == [-10..-1, 1..10] }
     test { ((1..10) + (-10..0)).assert == [-10..10] }
     test { ((1..10) + (-10..1)).assert == [-10..10] }