Cleanup more and fix a bug in my test and code.

Author: LoneWandererProductions

CommonLibraryTests/IoFileHandler.cs

@@ -283,7 +283,7 @@ public async Task AppendageOfFileAsync()
 
         //Rename, reorder Numbers
         count = await FileNameConverter.ReOrderNumbers(_renamePath, false);
-        Assert.AreEqual(5, count, "Not enough files renamed");
+        Assert.AreEqual(1, count, "Not enough files renamed");
 
         check = File.Exists(Path.Combine(_renamePath, "fifth_234234234"));
         Assert.IsTrue(check, "File was not correct");

FileHandler/FileHandleRenameExtension.cs

@@ -2,116 +2,128 @@
  * COPYRIGHT:   See COPYING in the top level directory
  * PROJECT:     FileHandler
  * FILE:        FileHandler/FileHandleRenameExtension.cs
- * PURPOSE:     Extension for FileHandleRename
- * PROGRAMER:   Peter Geinitz (Wayfarer)
+ * PURPOSE:     Unified safe rename helpers (append/remove/replace/reorder)
+ * PROGRAMER:   Peter Geinitz (Wayfarer) – Refactor by ChatGPT
  */
 
-// ReSharper disable MemberCanBeInternal
-
 using System;
 using System.Linq;
-using System.Text.RegularExpressions;
 
 namespace FileHandler;
 
 /// <summary>
-///     Some string Extensions
+///     String helpers for renaming files.
+///     All operations share a unified input normalization pipeline,
+///     but preserve the outward behavior of the original implementation.
 /// </summary>
 public static class FileHandleRenameExtension
 {
     /// <summary>
-    ///     The regex Instance
-    /// </summary>
-    private static readonly Regex Regex = new(@"\D+");
-
-    /// <summary>
-    ///     Removes the appendage.
+    /// Removes an appendage if present.
     /// </summary>
     /// <param name="str">The string.</param>
     /// <param name="appendage">The appendage.</param>
-    /// <param name="comparison">The string comparison option.</param>
-    /// <returns>
-    ///     string with the removed appendage
-    /// </returns>
-    /// <exception cref="ArgumentNullException">
-    ///     str or appendage was empty
-    /// </exception>
+    /// <param name="comparison">The comparison.</param>
+    /// <returns>New File name.</returns>
     public static string RemoveAppendage(this string str, string appendage,
         StringComparison comparison = StringComparison.OrdinalIgnoreCase)
     {
-        ArgumentNullException.ThrowIfNull(str);
-
-        ArgumentNullException.ThrowIfNull(appendage);
+        str = NormalizeInput(str);
+        appendage = NormalizeSubInput(appendage);
 
         return !str.StartsWith(appendage, comparison)
             ? str
-            : str.Remove(0, appendage.Length);
+            : str.Substring(appendage.Length);
     }
 
     /// <summary>
-    ///     Adds the appendage.
+    /// Adds an appendage if missing.
     /// </summary>
     /// <param name="str">The string.</param>
     /// <param name="appendage">The appendage.</param>
-    /// <param name="comparison">The string comparison option.</param>
-    /// <returns>
-    ///     string with added appendage
-    /// </returns>
-    /// <exception cref="ArgumentNullException">
-    ///     str or appendage was empty
-    /// </exception>
+    /// <param name="comparison">The comparison.</param>
+    /// <returns>New File name.</returns>
     public static string AddAppendage(this string str, string appendage,
         StringComparison comparison = StringComparison.OrdinalIgnoreCase)
     {
-        ArgumentNullException.ThrowIfNull(str);
+        str = NormalizeInput(str);
+        appendage = NormalizeSubInput(appendage);
 
-        ArgumentNullException.ThrowIfNull(appendage);
-
-        return str.StartsWith(appendage, comparison) ? str : string.Concat(appendage, str);
+        return str.StartsWith(appendage, comparison)
+            ? str
+            : appendage + str;
     }
 
     /// <summary>
-    ///     Replaces the part.
+    /// Replaces a substring only if it exists.
     /// </summary>
     /// <param name="str">The string.</param>
     /// <param name="targetStr">The target string.</param>
-    /// <param name="update">The update string.</param>
-    /// <param name="comparison">The string comparison option.</param>
-    /// <returns>
-    ///     string with replaced substring
-    /// </returns>
-    /// <exception cref="ArgumentNullException">str was empty</exception>
+    /// <param name="update">The update.</param>
+    /// <param name="comparison">The comparison.</param>
+    /// <returns>New File name.</returns>
     public static string ReplacePart(this string str, string targetStr, string update,
         StringComparison comparison = StringComparison.Ordinal)
     {
-        ArgumentNullException.ThrowIfNull(str);
+        str = NormalizeInput(str);
 
         if (string.IsNullOrEmpty(targetStr))
-        {
             return str;
-        }
 
-        return !str.Contains(targetStr, comparison) ? str : str.Replace(targetStr, update);
+        return str.Contains(targetStr, comparison)
+            ? str.Replace(targetStr, update)
+            : str;
     }
 
     /// <summary>
-    ///     Reorders Numbers in a string and appends them.
+    /// Reorders all digits to the end and appends them with a separator.
+    /// Preserves original non-digit order and old behavior.
     /// </summary>
     /// <param name="str">The string.</param>
-    /// <returns>New string</returns>
+    /// <returns>New File name.</returns>
     public static string ReOrderNumbers(this string str)
     {
+        str = NormalizeInput(str);
+
         if (string.IsNullOrEmpty(str))
-        {
             return str;
-        }
 
-        var charsToRemove = Regex.Split(str);
-        var numbers = string.Concat(charsToRemove);
+        // Extract numeric parts
+        var digits = string.Concat(str.Where(char.IsDigit));
+
+        // Remove digits from the original string
+        var nonDigits = string.Concat(str.Where(c => !char.IsDigit(c)));
+
+        // Append separator + digits only if digits exist
+        if (string.IsNullOrEmpty(digits))
+            return str;
+
+        return nonDigits + FileHandlerResources.Append + digits;
+    }
+
+    /// <summary>
+    /// Ensures safe null handling and returns the normalized input.
+    /// Does NOT modify casing, punctuation, ordering, etc.
+    /// </summary>
+    /// <param name="str">The string.</param>
+    /// <returns>Normalized File name.</returns>
+    /// <exception cref="System.ArgumentNullException"></exception>
+    private static string NormalizeInput(string str)
+    {
+        // preserve original NullException behavior for compatibility
+        ArgumentNullException.ThrowIfNull(str);
+        return str;
+    }
 
-        return string.Concat(
-            charsToRemove.Where(c => !string.IsNullOrEmpty(c))
-                .Aggregate(str, (current, c) => current.Replace(c, string.Empty)), FileHandlerResources.Append,
-            numbers);
+    /// <summary>
+    /// Normalizes append/remove/replace inputs.
+    /// </summary>
+    /// <param name="str">The string.</param>
+    /// <returns>Normalized File name.</returns>
+    /// <exception cref="System.ArgumentNullException"></exception>
+    private static string NormalizeSubInput(string str)
+    {
+        ArgumentNullException.ThrowIfNull(str);
+        return str;
     }
 }