Keep a hard-broken hyphen on the line with the rest of its word [patch]

Extensions.Test/StringExtensionsTests.cs

@@ -578,6 +578,26 @@
 		CollectionAssert.AreEqual(new List<string> { "foobar-", "bazqux" }, result);
 	}
 
+	[TestMethod]
+	[DataRow("self-explanatory", 4f, new[] { "self", "-exp", "lana", "tory" })]
+	[DataRow("abcde-fghij", 5f, new[] { "abcde", "-fghi", "j" })]
+	[DataRow("well-known e-mail", 4f, new[] { "well", "-kno", "wn", "e-", "mail" })]
+	public void NominalWordWrapNeverLeavesALineOfOnlyHyphens(string input, float maxChars, string[] expected)
+	{
+		// A hard break that cuts only the trailing hyphen off a chunk keeps the next chunk of the word on the hyphen's line (#182).
+		List<string> result = [.. input.NominalWordWrap(maxChars, 1f)];
+		CollectionAssert.AreEqual(expected, result);
+		Assert.IsFalse(result.Any(line => line.Length > 0 && line.Trim('-').Length == 0), "No line should hold only hyphens.");
+		Assert.IsFalse(result.Any(line => line.Length > maxChars), "No line should be wider than the width.");
+	}
+
+	[TestMethod]
+	public void NominalWordWrapAtWidthOneKeepsTheHyphenOnItsOwnLine()
+	{
+		List<string> result = [.. "x-ray".NominalWordWrap(1f, 1f)];
+		CollectionAssert.AreEqual(new List<string> { "x", "-", "r", "a", "y" }, result);
+	}
+
 	[TestMethod]
 	public void NominalWordWrapDoesNotBreakOnUnderscores()
 	{

Extensions/StringExtensions.cs

@@ -122,9 +122,9 @@
 #endif
 	}
 
 	private static Regex LineEndingRegexUnix { get; } = new(@"(?<!\r)\n", RegexOptions.Compiled);
 	private static Regex LineEndingRegexWindows { get; } = new(@"\r\n", RegexOptions.Compiled);
 	private static Regex LineEndingRegexMac { get; } = new(@"\r(?!\n)", RegexOptions.Compiled);
 
 	// One pass over every kind of line ending. Normalizing in several passes lets an earlier pass
 	// build a sequence the next one reads differently: under Mac, "\r\n\n" became "\r" + "\n", a new CRLF.
@@ -271,7 +271,7 @@
 	/// </summary>
 	private const char SoftHyphen = '­';
 
 	private static IEnumerable<string> NominalWordWrapIterator(string text, int maxCharsPerLine)
 	{
 		string normalized = text.NormalizeLineEndings(LineEndingStyle.Unix);
 		string[] segments = normalized.Split('\n');
@@ -292,10 +292,24 @@
 			// The atoms on the current line after its first, with the line length before each (and its separator), so a
 			// break that would not leave room for a rendered hyphen can fall back to an earlier boundary.
 			List<(int Index, int StartLength)> lineAtoms = [];
+
+			// Whether the current line is only the hyphen run a hard break cut off the end of a chunk ("self-" at width 4
+			// leaves "-"). The boundary after it is not taken, so the line never ends up holding nothing but hyphens.
+			bool lineIsHyphenRemainder = false;
 			for (int i = 0, next; i < atoms.Count; i = next)
 			{
 				next = i + 1;
 				(string atomText, bool glueSpace, bool hyphenBefore, bool canBreak) = atoms[i];
+				bool joinRemainder = lineIsHyphenRemainder && !glueSpace;
+				lineIsHyphenRemainder = false;
+				if (joinRemainder)
+				{
+					// The next chunk of the same word continues on the hyphen's line, and is hard-broken from there as usual.
+					atomText = line + atomText;
+					line.Clear();
+					lineAtoms.Clear();
+				}
+
 				bool atLineStart = line.Length == 0;
 				int separatorLength = (!atLineStart && glueSpace) ? 1 : 0;
 				int projectedLength = line.Length + separatorLength + atomText.Length;
@@ -332,7 +346,7 @@
 					yield return line.ToString();
 					line.Clear();
 					lineAtoms.Clear();
 					atLineStart = true;
 				}
 				else if (!atLineStart)
 				{
@@ -347,21 +361,14 @@
 				}
 
 				// At the start of a fresh line: place the atom, hard-breaking it if it still cannot fit.
-				string remaining = atomText;
-				while (remaining.Length > maxCharsPerLine)
+				List<string> fullLines = HardBreak(atomText, maxCharsPerLine, out string remaining);
+				foreach (string fullLine in fullLines)
 				{
-					int cut = maxCharsPerLine;
-					if (char.IsHighSurrogate(remaining[cut - 1]) && char.IsLowSurrogate(remaining[cut]))
-					{
-						// Never split a surrogate pair. At a width of one, let the pair overhang instead.
-						cut = cut > 1 ? cut - 1 : 2;
-					}
-
-					yield return remaining.Substring(0, cut);
-					remaining = remaining.Substring(cut);
+					yield return fullLine;
 				}
 
 				line.Append(remaining);
+				lineIsHyphenRemainder = fullLines.Count > 0 && remaining.Length > 0 && remaining.Trim('-').Length == 0;
 			}
 
 			if (line.Length > 0)
@@ -371,6 +378,33 @@
 		}
 	}
 
+	/// <summary>
+	/// Cuts text that is wider than a line into full lines, never splitting a surrogate pair.
+	/// </summary>
+	/// <param name="text">The text to place at the start of a line.</param>
+	/// <param name="maxCharsPerLine">The line width in characters.</param>
+	/// <param name="remaining">The text left over for the last, partly filled line.</param>
+	/// <returns>The full lines cut from the start of the text, in order.</returns>
+	private static List<string> HardBreak(string text, int maxCharsPerLine, out string remaining)
+	{
+		List<string> fullLines = [];
+		remaining = text;
+		while (remaining.Length > maxCharsPerLine)
+		{
+			int cut = maxCharsPerLine;
+			if (char.IsHighSurrogate(remaining[cut - 1]) && char.IsLowSurrogate(remaining[cut]))
+			{
+				// Never split a surrogate pair. At a width of one, let the pair overhang instead.
+				cut = cut > 1 ? cut - 1 : 2;
+			}
+
+			fullLines.Add(remaining.Substring(0, cut));
+			remaining = remaining.Substring(cut);
+		}
+
+		return fullLines;
+	}
+
 	private static List<(string Text, bool GlueSpace, bool HyphenBefore, bool CanBreak)> BuildAtoms(string segment)
 	{
 		List<(string Text, bool GlueSpace, bool HyphenBefore, bool CanBreak)> atoms = [];
@@ -428,7 +462,7 @@
 		return words;
 	}
 
 	private static List<(string Text, bool HyphenBefore)> ChunkWord(string word)
 	{
 		// Split a whitespace-delimited word into break-units at hyphenation opportunities:
 		// after a visible hyphen (kept on the left chunk) or at a soft hyphen (removed unless a break lands there).