restruct: method ToArguments from string

Author: emako

src/Flucli.Test/Program.cs

@@ -7,8 +7,23 @@ internal class Program
 {
     static void Main(string[] args)
     {
-        string[] _ = "explorer.exe /select,\"C:\\Windows\\explorer.exe\""
-            .ToArguments().ToArray();
+        // Argument parser
+        {
+            // Output: explorer.exe, /select,"C:\Windows\explorer.exe"
+            string[] _1 = "explorer.exe /select,\"C:\\Windows\\explorer.exe\""
+                .ToArguments().ToArray();
+
+            string _2 = new string[]
+            {
+                "https://test.com",
+                "\"https://test.com\"",
+                "https://",
+                "https:/",
+                "https:",
+                "https",
+                "/select,\"C:\\Windows\\explorer.exe\"",
+            }.ToArguments();
+        }
 
         Task.Run(async () =>
         {

src/Flucli/Cli.cs

@@ -469,10 +469,10 @@ public override string ToString()
     {
         if (PipeTo != null)
         {
-            return $"{FileName.ToQuoteMarkArguments()} {Arguments} | {PipeTo}";
+            return $"{FileName.ToArguments()} {Arguments} | {PipeTo}";
         }
 
-        return $"{FileName.ToQuoteMarkArguments()} {Arguments}";
+        return $"{FileName.ToArguments()} {Arguments}";
     }
 
     public static Cli operator |(Cli source, PipeTarget target)

src/Flucli/Utils/ArgumentBuilderOption.cs

@@ -0,0 +1,61 @@
+namespace Flucli.Utils;
+
+public class ArgumentBuilderOption
+{
+    /// <summary>
+    /// Default Quote
+    /// </summary>
+    public const string Quote = "\"";
+
+    /// <summary>
+    /// <seealso cref="QuoteReplace.DoubleQuote"/>
+    /// </summary>
+    public const string DoubleQuote = "\"";
+
+    /// <summary>
+    /// <seealso cref="QuoteReplace.BackSlashQuote"/>
+    /// </summary>
+    public const string BackSlashQuote = "\\\"";
+
+    /// <summary>
+    /// Single instance of this class.
+    /// </summary>
+    public static ArgumentBuilderOption Default { get; } = new();
+
+    /// <summary>
+    /// Options for handling separator within argument strings.
+    /// </summary>
+    public string Separator { get; set; } = " ";
+
+    /// <summary>
+    /// Options for handling quotes within argument strings.
+    /// </summary>
+    public QuoteReplace QuoteReplace { get; set; } = QuoteReplace.None;
+
+    /// <summary>
+    /// Some issues to be fixed here about url scheme.
+    /// Which argument Starts with `https://` or `http://` should be added quote.
+    /// </summary>
+    public bool IsQuoteScheme { get; set; } = true;
+}
+
+/// <summary>
+/// Options for handling quotes within argument strings.
+/// </summary>
+public enum QuoteReplace
+{
+    /// <summary>
+    /// No special handling for quotes
+    /// </summary>
+    None,
+
+    /// <summary>
+    /// Replace each quote with two quotes
+    /// </summary>
+    DoubleQuote,
+
+    /// <summary>
+    /// Escape each quote with a backslash
+    /// </summary>
+    BackSlashQuote,
+}

src/Flucli/Utils/Extensions/ArgumentExtension.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Security;
 using System.Text;
@@ -62,40 +63,52 @@ public static IEnumerable<string> ToArguments(this string cli)
     /// Joins a collection of arguments into a single command-line string, quoting arguments as needed.
     /// </summary>
     /// <param name="cli">The arguments to join into a command-line string.</param>
+    /// <param name="option"></param>
     /// <returns>A single string representing the command-line.</returns>
-    public static string ToArguments(this IEnumerable<string> cli)
+    public static string ToArguments(this IEnumerable<string> cli, ArgumentBuilderOption? option = null)
     {
-        return string.Join(" ", cli?.Select(arg => arg.ToQuoteMarkArguments()) ?? []);
+        option ??= ArgumentBuilderOption.Default;
+
+        return string.Join(option.Separator, cli?.Select(arg => arg.ToArguments(option)) ?? []);
     }
 
     /// <summary>
     /// Adds quotes to an argument string if necessary, with options for handling existing quotes.
     /// </summary>
     /// <param name="arg">The argument string to process.</param>
-    /// <param name="quoteType">Specifies how to handle existing quotes within the argument.</param>
+    /// <param name="option"></param>
     /// <returns>The argument string, possibly with added quotes.</returns>
-    public static string ToQuoteMarkArguments(this string arg, QuoteReplace quoteType = QuoteReplace.None)
+    public static string ToArguments(this string arg, ArgumentBuilderOption? option = null)
     {
         if (string.IsNullOrEmpty(arg))
         {
             return arg;
         }
 
-        switch (quoteType)
+        option ??= ArgumentBuilderOption.Default;
+
+        string quote = ArgumentBuilderOption.Quote;
+
+        switch (option.QuoteReplace)
         {
             case QuoteReplace.DoubleQuote:
-                arg = arg.Replace("\"", "\"\"");
+                arg = arg.Replace(ArgumentBuilderOption.Quote, ArgumentBuilderOption.DoubleQuote);
+                quote = ArgumentBuilderOption.DoubleQuote;
                 break;
 
             case QuoteReplace.BackSlashQuote:
-                arg = arg.Replace("\"", "\\\"");
+                arg = arg.Replace(ArgumentBuilderOption.Quote, ArgumentBuilderOption.BackSlashQuote);
+                quote = ArgumentBuilderOption.BackSlashQuote;
                 break;
         }
 
-        if (!(arg.StartsWith("\"") && arg.EndsWith("\"")) // If the argument is not already quoted
-           && arg.Contains(' ') || arg.Contains('\"'))    // And if the argument contains spaces or quotes
+        // If the argument is not already quoted
+        // if the argument contains spaces
+        // If the argument is a valid URI
+        if ((!(arg.StartsWith(quote) && arg.EndsWith(quote)) && arg.Contains(' '))
+           || (option.IsQuoteScheme && Uri.TryCreate(arg, UriKind.Absolute, out _)))
         {
-            arg = $"\"{arg}\"";
+            arg = quote + arg + quote;
         }
         return arg;
     }
@@ -109,18 +122,12 @@ public static (string, IEnumerable<string>) ToFileNameWithArguments(this string
     {
         IEnumerable<string> args = cli.ToArguments();
 
-        if (args.Count() == 0)
-        {
-            return (cli, []);
-        }
-        else if (args.Count() == 1)
-        {
-            return (args.First(), []);
-        }
-        else
+        return args.Count() switch
         {
-            return (args.First(), args.Skip(1));
-        }
+            0 => (cli, []),
+            1 => (args.First(), []),
+            _ => (args.First(), args.Skip(1)),
+        };
     }
 
     /// <summary>
@@ -139,25 +146,4 @@ public static SecureString ToSecureString(this string str)
         secureString.MakeReadOnly();
         return secureString;
     }
-
-    /// <summary>
-    /// Options for handling quotes within argument strings.
-    /// </summary>
-    public enum QuoteReplace
-    {
-        /// <summary>
-        /// No special handling for quotes
-        /// </summary>
-        None,
-
-        /// <summary>
-        /// Replace each quote with two quotes
-        /// </summary>
-        DoubleQuote,
-
-        /// <summary>
-        /// Escape each quote with a backslash
-        /// </summary>
-        BackSlashQuote,
-    }
 }