Implement opt-in for MinimumRaggedness. Runs about 30x slower than the greedy algorithm but with much nicer looking results. Closes #2

Author: bbrks

benchmark_test.go

@@ -26,3 +26,43 @@ func BenchmarkWrap120(b *testing.B)  { benchmarkWrap(b, 120) }
 func BenchmarkWrap500(b *testing.B)  { benchmarkWrap(b, 500) }
 func BenchmarkWrap1000(b *testing.B) { benchmarkWrap(b, 1000) }
 func BenchmarkWrap5000(b *testing.B) { benchmarkWrap(b, 5000) }
+
+func benchmarkWrapOptimal(b *testing.B, limit int) {
+	w := wrap.NewWrapper()
+	w.MinimumRaggedness = true
+
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		w.Wrap(loremIpsums[0], limit)
+	}
+}
+
+func BenchmarkWrapOptimal10(b *testing.B)   { benchmarkWrapOptimal(b, 10) }
+func BenchmarkWrapOptimal25(b *testing.B)   { benchmarkWrapOptimal(b, 25) }
+func BenchmarkWrapOptimal80(b *testing.B)   { benchmarkWrapOptimal(b, 80) }
+func BenchmarkWrapOptimal120(b *testing.B)  { benchmarkWrapOptimal(b, 120) }
+func BenchmarkWrapOptimal500(b *testing.B)  { benchmarkWrapOptimal(b, 500) }
+func BenchmarkWrapOptimal1000(b *testing.B) { benchmarkWrapOptimal(b, 1000) }
+
+// BenchmarkGreedyVsOptimal compares greedy and optimal algorithms side by side.
+func BenchmarkGreedyVsOptimal(b *testing.B) {
+	input := loremIpsums[0]
+	limit := 80
+
+	b.Run("Greedy", func(b *testing.B) {
+		w := wrap.NewWrapper()
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			w.Wrap(input, limit)
+		}
+	})
+
+	b.Run("Optimal", func(b *testing.B) {
+		w := wrap.NewWrapper()
+		w.MinimumRaggedness = true
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			w.Wrap(input, limit)
+		}
+	})
+}

example_test.go

@@ -236,3 +236,31 @@ func ExampleWrapper_Wrap_prefix() {
 	// // laoreet aliquet. Donec gravida congue massa, et sollicitudin turpis lacinia
 	// // a. Fusce non tortor magna. Cras vel finibus tellus.
 }
+
+func ExampleWrapper_Wrap_minimumRaggedness() {
+	// This example demonstrates the difference between greedy and optimal wrapping.
+	// The input is designed to show how optimal wrapping produces more balanced lines.
+	var text = "a b c d e f g h i j k l m n o p"
+
+	fmt.Println("Greedy (default):")
+	w := wrap.NewWrapper()
+	w.StripTrailingNewline = true
+	fmt.Println(w.Wrap(text, 9))
+
+	fmt.Println()
+	fmt.Println("Optimal (MinimumRaggedness):")
+	w.MinimumRaggedness = true
+	fmt.Println(w.Wrap(text, 9))
+	// Output:
+	// Greedy (default):
+	// a b c d e
+	// f g h i j
+	// k l m n o
+	// p
+	//
+	// Optimal (MinimumRaggedness):
+	// a b c d
+	// e f g h
+	// i j k l
+	// m n o p
+}

fuzz_test.go

@@ -102,6 +102,21 @@ func FuzzWrap(f *testing.F) {
 				}
 			}
 		}
+
+		// Test with MinimumRaggedness
+		w.CutLongWords = false
+		w.MinimumRaggedness = true
+		result4 := w.Wrap(input, limit)
+		if !utf8.ValidString(result4) {
+			t.Errorf("result with MinimumRaggedness is not valid UTF-8: %q", result4)
+		}
+
+		// Test MinimumRaggedness with CutLongWords
+		w.CutLongWords = true
+		result5 := w.Wrap(input, limit)
+		if !utf8.ValidString(result5) {
+			t.Errorf("result with MinimumRaggedness+CutLongWords is not valid UTF-8: %q", result5)
+		}
 	})
 }
 
@@ -146,18 +161,21 @@ func FuzzWrapWithOptions(f *testing.F) {
 			t.Errorf("result is not valid UTF-8: %q", result)
 		}
 
-		// Test all option combinations
+		// Test all option combinations including MinimumRaggedness
 		for _, strip := range []bool{false, true} {
 			for _, cut := range []bool{false, true} {
 				for _, includeLimit := range []bool{false, true} {
-					w.StripTrailingNewline = strip
-					w.CutLongWords = cut
-					w.LimitIncludesPrefixSuffix = includeLimit
-
-					result := w.Wrap(input, limit)
-					if !utf8.ValidString(result) {
-						t.Errorf("result is not valid UTF-8 with strip=%v cut=%v includeLimit=%v: %q",
-							strip, cut, includeLimit, result)
+					for _, optimal := range []bool{false, true} {
+						w.StripTrailingNewline = strip
+						w.CutLongWords = cut
+						w.LimitIncludesPrefixSuffix = includeLimit
+						w.MinimumRaggedness = optimal
+
+						result := w.Wrap(input, limit)
+						if !utf8.ValidString(result) {
+							t.Errorf("result is not valid UTF-8 with strip=%v cut=%v includeLimit=%v optimal=%v: %q",
+								strip, cut, includeLimit, optimal, result)
+						}
 					}
 				}
 			}