Various code tidy ups, primarily regex related.

Tkael · Tkael · commit 45050a0207f1 · 2026-04-26T00:59:59.000-07:00
diff --git a/EDDNResponder/Toolkit/LocationAugmenter.cs b/EDDNResponder/Toolkit/LocationAugmenter.cs
@@ -2,7 +2,6 @@
 using EddiDataDefinitions;
 using System;
 using System.Collections.Generic;
-using System.Text.RegularExpressions;
 using Utilities;
 
 namespace EddiEddnResponder.Toolkit
@@ -350,8 +349,7 @@ internal bool ConfirmScan(string scannedBodyName)
                     // If the body doesn't start with the system name, it should also 
                     // not match a naming pattern for a procedurally generated name.
                     // If it does, it's (probably) in the wrong place.
-                    var isProcGenName = new Regex(@"[A-Z][A-Z]-[A-Z] [a-h][0-9]");
-                    if (!isProcGenName.IsMatch(scannedBodyName))
+                    if (!GeneratedRegex.PROC_GEN_SYSTEM_BODY().IsMatch(scannedBodyName))
                     {
                         return true;
                     }
diff --git a/EddiCore/EDDI.cs b/EddiCore/EDDI.cs
@@ -21,7 +21,6 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
-using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using Utilities;
@@ -95,9 +94,9 @@ private void SetGameVersion(string v)
                     // The game version is typically a Semantic Version string (e.g. "4.0.0.102")
                     // but may sometimes include additional information (e.g. "4.0.0.32 (Alpha Phase 4 Hotfix 9)")
                     // or may be missing a Semantic Version altogether (e.g. "Fleet Carriers Update - Patch 11")
-                    var versionRegex = new Regex(@"^(?<engine>0|[1-9]\d*)\.(?<major>0|[1-9]\d*)(?:\.(?<minor>\d*))?(?:\.(?<patch>\d*))?");
-                    GameVersion = !string.IsNullOrEmpty(v) &&
-                                  System.Version.TryParse(versionRegex.Match(v).Value, out var versionResult)
+                    GameVersion = !string.IsNullOrEmpty( v ) &&
+                                  System.Version.TryParse( GeneratedRegex.SemanticVersionRegex().Match( v ).Value,
+                                      out var versionResult )
                         ? versionResult
                         : null;
 
diff --git a/EddiCore/Upgrader/EddiUpgrader.cs b/EddiCore/Upgrader/EddiUpgrader.cs
@@ -7,7 +7,6 @@
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Reflection;
-using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Utilities;
 
@@ -95,7 +94,7 @@ private static void ProcessRelease ( JObject release )
         {
             // Get the version information, removing any prefixing description and separator
             var version = release.Value<string>("tag_name");
-            version = Regex.Replace( version, @"(^\w+[\\\/:_\-\|+=#@&%!~^*])+", "" );
+            version = GeneratedRegex.EddiVersionRegex().Match( version ).Value;
 
             if ( release["assets"] is JArray assets )
             {
diff --git a/GalnetMonitor/GalnetFeedItemNormalizer.cs b/GalnetMonitor/GalnetFeedItemNormalizer.cs
@@ -101,7 +101,7 @@ private static string RemoveControlChars ( string value )
 
         private static string StripDoubleOrMoreWhiteSpace ( string value )
         {
-            return GeneratedRegex.WhiteMultiSpaceRegex().Replace( value, " " );
+            return GeneratedRegex.WhiteSpaceTwoOrMoreRegex().Replace( value, " " );
         }
 
         private static string StripHTML ( string value )
diff --git a/SpeechResponder/CustomFunctions/ShipCallsign.cs b/SpeechResponder/CustomFunctions/ShipCallsign.cs
@@ -8,7 +8,6 @@
 using System;
 using System.Linq;
 using System.Text;
-using System.Text.RegularExpressions;
 
 namespace EddiSpeechResponder.CustomFunctions
 {
@@ -92,14 +91,29 @@ internal static string phoneticCallsign(Ship ship, string id)
             return sb.ToString();
         }
 
-        private static string Get3LeadingCharacters(string input)
+        private static string Get3LeadingCharacters ( string input )
         {
-            // Obtain the first three characters of the input string, zero padded and converted to ICAO (e.g. "A" becomes "Alpha Zero Zero")
-            return SpeechConversions.ICAO(new Regex("[^a-zA-Z0-9]")
-                .Replace(input, "")
-                .ToUpperInvariant()
-                .PadRight(3, '0')
-                .Substring(0, 3));
+            Span<char> buffer = stackalloc char[3];
+            var count = 0;
+
+            if ( !string.IsNullOrEmpty( input ) )
+            {
+                foreach ( var c in input )
+                {
+                    if ( char.IsLetterOrDigit( c ) )
+                    {
+                        buffer[ count++ ] = char.ToUpperInvariant( c );
+                        if ( count == 3 ) { break; }
+                    }
+                }
+            }
+
+            while ( count < 3 )
+            {
+                buffer[ count++ ] = '0';
+            }
+
+            return SpeechConversions.ICAO( new string( buffer ) );
         }
     }
 }
diff --git a/SpeechResponder/ScriptResolverService/ScriptResolver.cs b/SpeechResponder/ScriptResolverService/ScriptResolver.cs
@@ -131,7 +131,7 @@ public static string resolveFromValue(string script, IContext context, bool isTo
                 // Tidy up the output script
                 if ( isTopLevelScript )
                 {
-                    result = GeneratedRegex.WhiteMultiSpaceRegex().Replace( result, " " )
+                    result = GeneratedRegex.WhiteSpaceTwoOrMoreRegex().Replace( result, " " )
                         .Replace( " ,", "," )
                         .Replace( " .", "." ).Trim();
                     result = result.Trim() == "" ? null : result.Trim();
diff --git a/SpeechService/SpeechConversions/PhoneticBody.cs b/SpeechService/SpeechConversions/PhoneticBody.cs
@@ -68,7 +68,7 @@ private static string getPhoneticBody(string body, bool useICAO = false)
                 }
             }
 
-            return GeneratedRegex.WhiteMultiSpaceRegex().Replace(string.Join(" ", results), " ");
+            return GeneratedRegex.WhiteSpaceTwoOrMoreRegex().Replace(string.Join(" ", results), " ");
         }
 
         private static string GetLastPart(Match match, int i, int j)
diff --git a/Tests/EddiVoiceAttackService/MessageSerializerTests.cs b/Tests/EddiVoiceAttackService/MessageSerializerTests.cs
@@ -208,7 +208,7 @@ public void Serialize_EventMessage_IncludesEventData ()
         }
 
         [ TestMethod ]
-        public void Serialize_EventMessage_WithModifyingCollection_DoesNotThrow ()
+        public async Task Serialize_EventMessage_WithModifyingCollection_DoesNotThrow ()
         {
             // Arrange: Create a mutable dictionary that simulates concurrent modification
             var payload = new Dictionary<string, object> { { "key1", "value1" } };
@@ -226,6 +226,7 @@ public void Serialize_EventMessage_WithModifyingCollection_DoesNotThrow ()
             };
 
             // Act: Modify the dictionary in a separate task while serializing
+            Exception exception = null;
             var serializationTask = Task.Run( () =>
             {
                 // Serialize multiple times to increase chance of collision
@@ -252,14 +253,18 @@ public void Serialize_EventMessage_WithModifyingCollection_DoesNotThrow ()
             // Assert: Both tasks should complete without exception
             try
             {
-                Task.WaitAll( [ serializationTask, modificationTask ], TimeSpan.FromSeconds( 5 ) );
-                Assert.IsTrue( serializationTask.IsCompletedSuccessfully );
-                Assert.IsTrue( modificationTask.IsCompletedSuccessfully );
+                await Task.WhenAll( serializationTask, modificationTask );
             }
-            catch ( AggregateException ex )
+            catch ( Exception ex )
             {
-                Assert.Fail( $"Serialization failed during concurrent modification: {ex.InnerException?.Message}" );
+                // Capture for debugging, but don't assert here
+                exception = ex;
             }
+
+            // Assert (outside the catch)
+            Assert.IsNull( exception, $"Serialization failed during concurrent modification: {exception}" );
+            Assert.IsTrue( serializationTask.IsCompletedSuccessfully );
+            Assert.IsTrue( modificationTask.IsCompletedSuccessfully );
         }
 
         [ TestMethod ]
diff --git a/Tests/ScriptResolverTest.cs b/Tests/ScriptResolverTest.cs
@@ -5,7 +5,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text.RegularExpressions;
 using System.Threading;
 using System.Windows;
 
@@ -156,12 +155,6 @@ public void TestResolverRecursedCustomFunctions()
             Assert.IsEmpty(results);
         }
 
-        [TestMethod]
-        public void TestResolverCallsign()
-        {
-            Assert.AreEqual( "ABC", new Regex("[^a-zA-Z0-9]").Replace("a-b. c", "").ToUpperInvariant().Substring(0, 3) );
-        }
-
         [TestMethod]
         public void TestUpgradeScript_FromDefault()
         {
diff --git a/Tests/SpeechUnitTests.cs b/Tests/SpeechUnitTests.cs
@@ -24,7 +24,7 @@ public void start()
 
         private string CondenseSpaces(string s)
         {
-            return GeneratedRegex.WhiteMultiSpaceRegex().Replace(s, " ");
+            return GeneratedRegex.WhiteSpaceRegex().Replace(s, " ");
         }
 
         [TestMethod]
diff --git a/Tests/VoiceAttackPluginTests.cs b/Tests/VoiceAttackPluginTests.cs
@@ -623,20 +623,21 @@ public void TestInitializeStandardValues_WithoutData_CompletesSuccessfully()
 
             // Act: Call initializeStandardValues when EDDI data may not be fully loaded
             // (simulates the early startup scenario where monitors haven't populated data yet)
+            Exception exception = null;
             try
             {
                 VoiceAttackVariables.initializeStandardValues();
             }
             catch (Exception ex)
             {
-                Assert.Fail($"initializeStandardValues should not throw exceptions during early startup. Exception: {ex.Message}");
+                exception = ex;
             }
 
             // Assert: Verify that initialization completed successfully
             // EDDI version should always be set (independent of EDDI data availability)
+            Assert.IsNull( exception, $"initializeStandardValues should not throw exceptions during early startup. Exception: {exception?.Message}" );
             var eddiVersion = mockVAProxy.GetText("EDDI version");
-            Assert.IsFalse(string.IsNullOrEmpty(eddiVersion), 
-                "EDDI version should be set after initialization");
+            Assert.IsFalse(string.IsNullOrEmpty(eddiVersion), "EDDI version should be set after initialization");
         }
     }
 }
diff --git a/Utilities/Diff.cs b/Utilities/Diff.cs
@@ -1,7 +1,6 @@
 ﻿using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Text.RegularExpressions;
 
 namespace Utilities
 {
@@ -378,7 +377,7 @@ private static int[] DiffCodes(string aText, Hashtable h, bool trimSpace, bool i
 
                 if (ignoreSpace)
                 {
-                    s = Regex.Replace(s, "\\s+", " ");
+                    s = GeneratedRegex.WhiteSpaceRegex().Replace(s, " ");
                 }
 
                 if (ignoreCase)
diff --git a/Utilities/Files.cs b/Utilities/Files.cs
@@ -307,7 +307,8 @@ private static bool TryWrite(string fileName, int attempts, string content)
             }
 
             var exceptions = new List<Exception>();
-            while ( maxAttempts-- > 0 )
+            var currAttempts = maxAttempts;
+            while ( currAttempts-- > 0 )
             {
                 if ( !IsFileLocked( fileInfo ) )
                 {
diff --git a/Utilities/GeneratedRegex.cs b/Utilities/GeneratedRegex.cs
@@ -28,6 +28,9 @@ public static partial class GeneratedRegex
         [GeneratedRegex( @"\d+(?:\s|$)", RegexOptions.Compiled )]
         public static partial Regex DIGIT ();
 
+        [ GeneratedRegex( @"(?<major>\d+).(?<minor>\d+).(?<patch>\d+)(-(?<phase>[a-z]+)(?<iteration>\d+))?", RegexOptions.Compiled ) ]
+        public static partial Regex EddiVersionRegex ();
+        
         [GeneratedRegex( @"\s\(\d\)$", RegexOptions.Compiled )] 
         public static partial Regex EndingCountRegex (); // e.g. "Ancient Ruins (3)"
 
@@ -73,6 +76,9 @@ public static partial class GeneratedRegex
         [GeneratedRegex( @"^(?<SYSTEM>(?<SECTOR>[\w\s'.()-]+) (?<COORDINATES>(?<l1>[A-Za-z])(?<l2>[A-Za-z])-(?<l3>[A-Za-z]) (?<mcode>[A-Za-z])(?:(?<n1>\d+)-)?(?<n2>\d+))) ?(?<BODY>.*)$", RegexOptions.Compiled )]
         public static partial Regex PROC_GEN_SYSTEM_BODY ();
 
+        [ GeneratedRegex( @"^(?<engine>0|[1-9]\d*)\.(?<major>0|[1-9]\d*)(?:\.(?<minor>\d*))?(?:\.(?<patch>\d*))?", RegexOptions.Compiled ) ]
+        public static partial Regex SemanticVersionRegex ();
+        
         [GeneratedRegex( @"(?=\S)(?<STARS>(?<=^|\s)[A-E]+)? ?(?<PLANET>(?<=^|\s)\d{1,2})? ?(?<MOON>(?<=^|\s)[a-z])? ?(?<SUBMOON>(?<=^|\s)[a-z])? ?(?>(?<=^|\s)(?<RINGORBELTGROUP>[A-Z]) (?<RINGORBELTTYPE>Belt|Ring))? ?(?>(?<=^|\s)(?<CLUSTER>Cluster) (?<CLUSTERNUMBER>\d*))?$", RegexOptions.Compiled )]
         public static partial Regex SHORTBODY ();
 
@@ -125,13 +131,13 @@ public static partial class GeneratedRegex
 
         [GeneratedRegex( @"(?<=>)(.+)(?=<\/voice>)", RegexOptions.Compiled )]
         public static partial Regex VoiceSpeechExtractionRegex ();
-        
-        [GeneratedRegex( @"\s{2,}", RegexOptions.Compiled )]
-        public static partial Regex WhiteMultiSpaceRegex ();
 
         [GeneratedRegex( @"\s+", RegexOptions.Compiled )]
         public static partial Regex WhiteSpaceRegex ();
-        
+
+        [GeneratedRegex( @"\s{2,}", RegexOptions.Compiled )]
+        public static partial Regex WhiteSpaceTwoOrMoreRegex ();
+
         [GeneratedRegex( @"\w", RegexOptions.Compiled )]
         public static partial Regex WordCharacterRegex ();
         
diff --git a/Utilities/Versioning.cs b/Utilities/Versioning.cs
@@ -1,5 +1,4 @@
 ﻿using System;
-using System.Text.RegularExpressions;
 
 namespace Utilities
 {
@@ -46,8 +45,7 @@ public Version(string input)
             // https://docs.microsoft.com/en-us/dotnet/standard/base-types/best-practices?view=netframework-4.7.2 
             // I have concluded that an interpreted rather than compiled regex is the better choice here,
             // as version strings are parsed infrequently.
-            var pattern = @"^(?<major>\d+).(?<minor>\d+).(?<patch>\d+)(-(?<phase>[a-z]+)(?<iteration>\d+))?$";
-            var match = Regex.Match(input, pattern);
+            var match = GeneratedRegex.EddiVersionRegex().Match(input);
             var matchGroups = match.Groups;
 
             major = int.Parse(matchGroups["major"].Value);

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,6 @@`
`7`	`7`	`using System.Net.Http;`
`8`	`8`	`using System.Net.Http.Headers;`
`9`	`9`	`using System.Reflection;`
`10`		`-using System.Text.RegularExpressions;`
`11`	`10`	`using System.Threading.Tasks;`
`12`	`11`	`using Utilities;`
`13`	`12`
`@@ -95,7 +94,7 @@ private static void ProcessRelease ( JObject release )`
`95`	`94`	`{`
`96`	`95`	`// Get the version information, removing any prefixing description and separator`
`97`	`96`	`var version = release.Value<string>("tag_name");`
`98`		`- version = Regex.Replace( version, @"(^\w+[\\\/:_\-\\|+=#@&%!~^*])+", "" );`
	`97`	`+ version = GeneratedRegex.EddiVersionRegex().Match( version ).Value;`
`99`	`98`
`100`	`99`	`if ( release["assets"] is JArray assets )`
`101`	`100`	`{`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ private static string RemoveControlChars ( string value )`
`101`	`101`
`102`	`102`	`private static string StripDoubleOrMoreWhiteSpace ( string value )`
`103`	`103`	`{`
`104`		`- return GeneratedRegex.WhiteMultiSpaceRegex().Replace( value, " " );`
	`104`	`+ return GeneratedRegex.WhiteSpaceTwoOrMoreRegex().Replace( value, " " );`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`private static string StripHTML ( string value )`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ public static string resolveFromValue(string script, IContext context, bool isTo`
`131`	`131`	`// Tidy up the output script`
`132`	`132`	`if ( isTopLevelScript )`
`133`	`133`	`{`
`134`		`- result = GeneratedRegex.WhiteMultiSpaceRegex().Replace( result, " " )`
	`134`	`+ result = GeneratedRegex.WhiteSpaceTwoOrMoreRegex().Replace( result, " " )`
`135`	`135`	`.Replace( " ,", "," )`
`136`	`136`	`.Replace( " .", "." ).Trim();`
`137`	`137`	`result = result.Trim() == "" ? null : result.Trim();`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ private static string getPhoneticBody(string body, bool useICAO = false)`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`		`- return GeneratedRegex.WhiteMultiSpaceRegex().Replace(string.Join(" ", results), " ");`
	`71`	`+ return GeneratedRegex.WhiteSpaceTwoOrMoreRegex().Replace(string.Join(" ", results), " ");`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`private static string GetLastPart(Match match, int i, int j)`
Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ public void Serialize_EventMessage_IncludesEventData ()`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`[ TestMethod ]`
`211`		`- public void Serialize_EventMessage_WithModifyingCollection_DoesNotThrow ()`
	`211`	`+ public async Task Serialize_EventMessage_WithModifyingCollection_DoesNotThrow ()`
`212`	`212`	`{`
`213`	`213`	`// Arrange: Create a mutable dictionary that simulates concurrent modification`
`214`	`214`	`var payload = new Dictionary<string, object> { { "key1", "value1" } };`
`@@ -226,6 +226,7 @@ public void Serialize_EventMessage_WithModifyingCollection_DoesNotThrow ()`
`226`	`226`	`};`
`227`	`227`
`228`	`228`	`// Act: Modify the dictionary in a separate task while serializing`
	`229`	`+ Exception exception = null;`
`229`	`230`	`var serializationTask = Task.Run( () =>`
`230`	`231`	`{`
`231`	`232`	`// Serialize multiple times to increase chance of collision`
`@@ -252,14 +253,18 @@ public void Serialize_EventMessage_WithModifyingCollection_DoesNotThrow ()`
`252`	`253`	`// Assert: Both tasks should complete without exception`
`253`	`254`	`try`
`254`	`255`	`{`
`255`		`- Task.WaitAll( [ serializationTask, modificationTask ], TimeSpan.FromSeconds( 5 ) );`
`256`		`- Assert.IsTrue( serializationTask.IsCompletedSuccessfully );`
`257`		`- Assert.IsTrue( modificationTask.IsCompletedSuccessfully );`
	`256`	`+ await Task.WhenAll( serializationTask, modificationTask );`
`258`	`257`	`}`
`259`		`- catch ( AggregateException ex )`
	`258`	`+ catch ( Exception ex )`
`260`	`259`	`{`
`261`		`- Assert.Fail( $"Serialization failed during concurrent modification: {ex.InnerException?.Message}" );`
	`260`	`+ // Capture for debugging, but don't assert here`
	`261`	`+ exception = ex;`
`262`	`262`	`}`
	`263`	`+`
	`264`	`+ // Assert (outside the catch)`
	`265`	`+ Assert.IsNull( exception, $"Serialization failed during concurrent modification: {exception}" );`
	`266`	`+ Assert.IsTrue( serializationTask.IsCompletedSuccessfully );`
	`267`	`+ Assert.IsTrue( modificationTask.IsCompletedSuccessfully );`
`263`	`268`	`}`
`264`	`269`
`265`	`270`	`[ TestMethod ]`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public void start()`
`24`	`24`
`25`	`25`	`private string CondenseSpaces(string s)`
`26`	`26`	`{`
`27`		`- return GeneratedRegex.WhiteMultiSpaceRegex().Replace(s, " ");`
	`27`	`+ return GeneratedRegex.WhiteSpaceRegex().Replace(s, " ");`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`[TestMethod]`