Let a typed space match a no-break-space separator in Parse [patch]

PreciseNumber.Test/PreciseNumberParseCultureTests.cs

@@ -26,6 +26,28 @@ public class PreciseNumberParseCultureTests
 		NegativeSign = "-",
 	};
 
+	// Shaped like ru-RU, pl-PL or sv-SE, which group with U+00A0, and like de-CH, which groups with U+2019.
+	private static readonly NumberFormatInfo NoBreakSpaceGroups = new()
+	{
+		NumberDecimalSeparator = ",",
+		NumberGroupSeparator = "\u00A0",
+		NegativeSign = "-",
+	};
+
+	private static readonly NumberFormatInfo ApostropheGroups = new()
+	{
+		NumberDecimalSeparator = ",",
+		NumberGroupSeparator = "\u2019",
+		NegativeSign = "-",
+	};
+
+	private static readonly NumberFormatInfo NoBreakSpaceDecimal = new()
+	{
+		NumberDecimalSeparator = "\u00A0",
+		NumberGroupSeparator = ".",
+		NegativeSign = "-",
+	};
+
 	private static readonly NumberFormatInfo MultiCharacterSeparator = new()
 	{
 		NumberDecimalSeparator = "<>",
@@ -172,4 +194,51 @@ public void Parse_ReadsACulturesNegativeSignOnlyWhenTheStyleAllowsIt()
 		Assert.IsFalse(PreciseNumber.TryParse("−2", NumberStyles.None, CommaDecimal, out _));
 		Assert.IsFalse(PreciseNumber.TryParse("-2", NumberStyles.None, CommaDecimal, out _));
 	}
+
+	// A keyboard types U+0020, and every BCL numeric type lets it stand in for a U+00A0 or U+202F
+	// separator, so generic INumberBase<T>.Parse code failed only for PreciseNumber.
+	[TestMethod]
+	[DataRow("1 234,5", "1234.5")]
+	[DataRow("-1 234 567", "-1234567")]
+	[DataRow("1 234 567,25", "1234567.25")]
+	public void Parse_AcceptsATypedSpaceForANoBreakSpaceGroupSeparator(string input, string expected)
+	{
+		foreach (NumberFormatInfo format in new[] { NarrowSpaceGroups, NoBreakSpaceGroups })
+		{
+			Assert.AreEqual(P(expected), PreciseNumber.Parse(input, format));
+			Assert.AreEqual(P(expected), PreciseNumber.Parse(input, NumberStyles.Number, format));
+			Assert.AreEqual(P(expected), PreciseNumber.Parse(input, NumberStyles.Any, format));
+			Assert.AreEqual(decimal.Parse(input, NumberStyles.Number, format), PreciseNumber.Parse(input, NumberStyles.Number, format).To<decimal>());
+		}
+	}
+
+	[TestMethod]
+	public void Parse_AcceptsATypedSpaceForANoBreakSpaceDecimalSeparator()
+	{
+		Assert.AreEqual(P("1.5"), PreciseNumber.Parse("1 5", NumberStyles.Number, NoBreakSpaceDecimal));
+		Assert.AreEqual(decimal.Parse("1 5", NumberStyles.Number, NoBreakSpaceDecimal), PreciseNumber.Parse("1 5", NumberStyles.Number, NoBreakSpaceDecimal).To<decimal>());
+	}
+
+	[TestMethod]
+	public void Parse_StillAcceptsTheRealNoBreakSpace()
+	{
+		Assert.AreEqual(P("1234.5"), PreciseNumber.Parse("1\u202F234,5", NarrowSpaceGroups));
+		Assert.AreEqual(P("1234.5"), PreciseNumber.Parse("1\u00A0234,5", NoBreakSpaceGroups));
+	}
+
+	[TestMethod]
+	public void Parse_DoesNotLetASpaceStandInForOtherSeparators()
+	{
+		Assert.IsFalse(PreciseNumber.TryParse("1 234,5", NumberStyles.Number, ApostropheGroups, out _));
+		Assert.IsFalse(PreciseNumber.TryParse("1 234,5", NumberStyles.Number, CommaDecimal, out _));
+		Assert.IsFalse(PreciseNumber.TryParse("1 234", NumberStyles.Number, CultureInfo.InvariantCulture, out _));
+		Assert.IsFalse(PreciseNumber.TryParse("1\u00A0234", NumberStyles.Number, NarrowSpaceGroups, out _));
+	}
+
+	[TestMethod]
+	public void Parse_RejectsATypedSpaceWhenTheStyleDoesNotAllowThousands()
+	{
+		Assert.IsFalse(PreciseNumber.TryParse("1 234", NumberStyles.Float, NarrowSpaceGroups, out _));
+		Assert.IsFalse(PreciseNumber.TryParse("1 234", NumberStyles.Float, NoBreakSpaceGroups, out _));
+	}
 }

PreciseNumber/PreciseNumber.cs

@@ -744,7 +744,7 @@
 	/// A fixed precision such as <c>E15</c> rounds values that need 17 digits, which turns
 	/// <see cref="double.MaxValue"/> into a number that converts back to infinity.
 	/// </remarks>
 	internal static string GetStringFormatForFloatType<TFloat>()
 		where TFloat : INumber<TFloat>
 		=> "R";
 
@@ -1205,7 +1205,7 @@
 	public static PreciseNumber MinMagnitudeNumber(PreciseNumber x, PreciseNumber y) => MinMagnitude(x, y);
 
 	/// <inheritdoc/>
 	public static PreciseNumber Parse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider)
 	{
 		// Read the separator and signs from the same culture TryFormat writes them with, so that
 		// Parse(x.ToString(p), p) round-trips for every provider.
@@ -1255,7 +1255,7 @@
 			for (int i = startIndex; i < s.Length; i++)
 			{
 				char c = s[i];
-				if (allowDecimalPoint && s[i..].StartsWith(decimalSeparator, StringComparison.Ordinal))
+				if (allowDecimalPoint && StartsWithSeparator(s[i..], decimalSeparator))
 				{
 					if (hasDecimal)
 					{
@@ -1263,14 +1263,14 @@
 					}
 
 					hasDecimal = true;
 					i += decimalSeparator.Length - 1;
 					continue;
 				}
 
 				// Group separators may only sit between integral digits.
-				if (allowThousands && !hasDecimal && digitCount > 0 && s[i..].StartsWith(groupSeparator, StringComparison.Ordinal))
+				if (allowThousands && !hasDecimal && digitCount > 0 && StartsWithSeparator(s[i..], groupSeparator))
 				{
 					i += groupSeparator.Length - 1;
 					continue;
 				}
 
@@ -1310,6 +1310,33 @@
 		}
 	}
 
+	/// <summary>
+	/// Determines whether <paramref name="s"/> starts with <paramref name="separator"/>, letting a U+0020
+	/// space in <paramref name="s"/> stand in for a U+00A0 or U+202F no-break space in the separator.
+	/// </summary>
+	/// <remarks>
+	/// Cultures such as fr-FR, ru-RU and sv-SE group digits with a no-break space, but a keyboard types
+	/// an ordinary one. The BCL numeric parsers accept it in their place, so <c>decimal.Parse("1 234,5", fr)</c>
+	/// succeeds, and this matches them. Every other character is compared ordinally.
+	/// </remarks>
+	private static bool StartsWithSeparator(ReadOnlySpan<char> s, ReadOnlySpan<char> separator)
+	{
+		if (s.Length < separator.Length)
+		{
+			return false;
+		}
+
+		for (int i = 0; i < separator.Length; i++)
+		{
+			if (s[i] != separator[i] && !(s[i] == ' ' && separator[i] is '\u00A0' or '\u202F'))
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
 	/// <summary>
 	/// Builds the value <see cref="Parse(ReadOnlySpan{char}, NumberStyles, IFormatProvider?)"/> read: the
 	/// written <paramref name="digits"/>, of which the last <paramref name="decimalDigits"/> follow the