Refactor path handling to use platform-specific separators

ModPaths and AdditionalFallbackPath are now single string properties using the platform-specific path separator, instead of IList<string>. SettingsBuilder splits and normalizes these paths accordingly. Help texts are updated, and unit tests are added to verify correct path parsing and normalization using a mock file system.

Author: AnakinRaW

src/ModVerify.CliApp/Settings/CommandLine/BaseModVerifyOptions.cs

@@ -25,10 +25,10 @@ internal abstract class BaseModVerifyOptions
                    "The argument cannot be combined with any of --mods, --game or --fallbackGame")]
     public string? TargetPath { get; init; }
 
-    [Option("mods", SetName = "manualPaths", Required = false, Default = null, Separator = ';',
-        HelpText = "The path of the mod to verify. To support submods, multiple paths can be separated using the ';' (semicolon) character. " +
+    [Option("mods", SetName = "manualPaths", Required = false, Default = null,
+        HelpText = "The path of the mod to verify. To support submods, multiple paths can be separated using the platform-specific path separator (';' on Windows, ':' on Linux). " +
                    "Leave empty, if you want to verify a game. If you want to use the interactive mode, leave this, --game and --fallbackGame empty.")]
-    public IList<string>? ModPaths { get; init; }
+    public string? ModPaths { get; init; }
 
     [Option("game", SetName = "manualPaths", Required = false, Default = null,
         HelpText = "The path of the base game. For FoC mods this points to the FoC installation, for EaW mods this points to the EaW installation. " +
@@ -47,10 +47,10 @@ internal abstract class BaseModVerifyOptions
     public GameEngineType? Engine { get; init; }
 
 
-    [Option("additionalFallbackPaths", Required = false, Separator = ';',
+    [Option("additionalFallbackPaths", Required = false,
         HelpText = "Additional fallback paths, which may contain assets that shall be included when doing the verification. Do not add EaW here. " +
-                   "Multiple paths can be separated using the ';' (semicolon) character.")]
-    public IList<string>? AdditionalFallbackPath { get; init; }
+                   "Multiple paths can be separated using the platform-specific path separator (';' on Windows, ':' on Linux).")]
+    public string? AdditionalFallbackPath { get; init; }
 
     [Option("parallel", Default = false,
         HelpText = "When set, game verifiers will run in parallel. " +

src/ModVerify.CliApp/Settings/SettingsBuilder.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO.Abstractions;
+using System.Linq;
 
 namespace AET.ModVerify.App.Settings;
 
@@ -136,24 +137,20 @@ AppReportSettings BuildReportSettings()
 
     private VerificationTargetSettings BuildTargetSettings(BaseModVerifyOptions options)
     {
+        var separator = _fileSystem.Path.PathSeparator;
+
         var modPaths = new List<string>();
-        if (options.ModPaths is not null)
+        if (!string.IsNullOrEmpty(options.ModPaths))
         {
-            foreach (var mod in options.ModPaths)
-            {
-                if (!string.IsNullOrEmpty(mod))
-                    modPaths.Add(_fileSystem.Path.GetFullPath(mod));
-            }
+            var split = options.ModPaths!.Split([separator], StringSplitOptions.RemoveEmptyEntries);
+            modPaths.AddRange(split.Select(s => _fileSystem.Path.GetFullPath(s)));
         }
 
         var fallbackPaths = new List<string>();
-        if (options.AdditionalFallbackPath is not null)
+        if (!string.IsNullOrEmpty(options.AdditionalFallbackPath))
         {
-            foreach (var fallback in options.AdditionalFallbackPath)
-            {
-                if (!string.IsNullOrEmpty(fallback))
-                    fallbackPaths.Add(_fileSystem.Path.GetFullPath(fallback));
-            }
+            var split = options.AdditionalFallbackPath!.Split([separator], StringSplitOptions.RemoveEmptyEntries);
+            fallbackPaths.AddRange(split.Select(s => _fileSystem.Path.GetFullPath(s)));
         }
 
         var gamePath = options.GamePath;

test/ModVerify.CliApp.Test/SettingsBuilderTest.cs

@@ -1,23 +1,72 @@
 using AET.ModVerify.App;
 using AET.ModVerify.App.Settings;
 using AET.ModVerify.App.Settings.CommandLine;
-using Microsoft.Extensions.DependencyInjection;
 using System.IO.Abstractions;
-using Testably.Abstractions;
+using Testably.Abstractions.Testing;
 using Xunit;
+using AnakinRaW.CommonUtilities.Testing;
 
 namespace ModVerify.CliApp.Test;
 
-public class SettingsBuilderTest
+public class SettingsBuilderTest : TestBaseWithFileSystem
 {
     private readonly SettingsBuilder _builder;
 
     public SettingsBuilderTest()
     {
-        var services = new ServiceCollection();
-        services.AddSingleton<IFileSystem>(new RealFileSystem());
-        var provider = services.BuildServiceProvider();
-        _builder = new SettingsBuilder(provider);
+        _builder = new SettingsBuilder(ServiceProvider);
+    }
+
+    protected override IFileSystem CreateFileSystem()
+    {
+        return new MockFileSystem();
+    }
+
+    [Theory]
+    [InlineData("path1", "path2")]
+    public void BuildSettings_Paths_SplitsCorrectly(string p1, string p2)
+    {
+        var separator = FileSystem.Path.PathSeparator;
+        var paths = $"{p1}{separator}{p2}";
+        var expected = new[] { FileSystem.Path.GetFullPath(p1), FileSystem.Path.GetFullPath(p2) };
+
+        var options = new VerifyVerbOption
+        {
+            ModPaths = paths,
+            AdditionalFallbackPath = paths,
+            TargetPath = "myPath"
+        };
+
+        var settings = _builder.BuildSettings(options);
+        
+        Assert.Equal(expected, settings.VerificationTargetSettings.ModPaths);
+        Assert.Equal(expected, settings.VerificationTargetSettings.AdditionalFallbackPaths);
+    }
+
+    [Fact]
+    public void BuildSettings_FallbackGamePath_RequiresGamePath()
+    {
+        var gamePath = "game";
+        var fallbackPath = "fallback";
+
+        var options = new VerifyVerbOption
+        {
+            GamePath = gamePath,
+            FallbackGamePath = fallbackPath,
+            TargetPath = "myPath"
+        };
+
+        var settings = _builder.BuildSettings(options);
+        Assert.Equal(FileSystem.Path.GetFullPath(fallbackPath), settings.VerificationTargetSettings.FallbackGamePath);
+
+        var optionsNoGame = new VerifyVerbOption
+        {
+            FallbackGamePath = fallbackPath,
+            TargetPath = "myPath"
+        };
+
+        var settingsNoGame = _builder.BuildSettings(optionsNoGame);
+        Assert.Null(settingsNoGame.VerificationTargetSettings.FallbackGamePath);
     }
 
     [Fact]