Extensions.cs

Go to the documentation of this file.

using System;
 
namespace getopt.net {
 
    using System.Linq;
    using System.Text;
 
    public enum OptStringPrefix {
        None,
 
        Plus = '+',
 
        Minus = '-'
    } 
 
    public static class Extensions {
 
        public static Option? FindOptionOrDefault(this Option[] list, string optName) {
            if (string.IsNullOrEmpty(optName)) { throw new ArgumentNullException(nameof(optName), "optName must not be null!"); }
 
            return Array.Find(list, o => o.Name?.Equals(optName, StringComparison.InvariantCulture) == true);
        }
 
        public static Option? FindOptionOrDefault(this Option[]? list, char optVal) => list?.ToList().Find(o => o.Value == optVal);
 
        public static string ToShortOptString(this Option[] list) {
            if (list is null || list.Length == 0) { return string.Empty; }
 
            var sBuilder = new StringBuilder();
 
            foreach (var opt in list) {
                sBuilder.Append((char)opt.Value);
                switch (opt.ArgumentType) {
                    case ArgumentType.Required:
                        sBuilder.Append(':');
                        break;
                    case ArgumentType.Optional:
                        sBuilder.Append(';');
                        break;
                    default: break;
                }
            }
 
            return sBuilder.ToString();
        }
 
        public static string ToShortOptString(this Option[] list, OptStringPrefix prefix) {
            if (list is null || list.Length == 0) { return string.Empty; }
 
            var sBuilder = new StringBuilder();
            if (prefix != OptStringPrefix.None) {
                sBuilder.Append((char)prefix);
            }
 
            sBuilder.Append(list.ToShortOptString());
 
            return sBuilder.ToString();
        }
 
        public static string GenerateHelpText(this GetOpt getopt, HelpTextConfig? generatorOptions = null) {
            const string Tab = "    ";
            if (getopt is null) { throw new ArgumentNullException(nameof(getopt), "getopt must not be null!"); }
 
            var options = getopt.Options;
            if (options is null || options.Length == 0) { return string.Empty; }
 
            var config = generatorOptions ?? HelpTextConfig.Default;
 
            var sBuilder = new StringBuilder();
 
            if (!string.IsNullOrEmpty(config.ApplicationName) && !string.IsNullOrEmpty(config.ApplicationVersion)) {
                sBuilder.Append($"{config.ApplicationName} {config.ApplicationVersion}");
                if (config.CopyrightDate is not null && !string.IsNullOrEmpty(config.CopyrightHolder)) {
                    sBuilder.Append($" © {config.CopyrightDate.Value.Year} {config.CopyrightHolder}");
                }
                sBuilder.AppendLine()
                        .AppendLine();
            }
 
            string shortOptPrefix = config.OptionConvention == OptionConvention.Windows ? "/" : "-";
            string longOptPrefix = config.OptionConvention == OptionConvention.Windows ? "/" : config.OptionConvention == OptionConvention.GnuPosix ? "--" : "-";
 
            sBuilder.AppendLine("Usage:");
            sBuilder.AppendLine($"{Tab}{config.ApplicationName ?? GetApplicationName()} [options]");
            if (config.ShowSupportedConventions) {
                sBuilder.AppendLine(
                    $"""
 
                    Supported option conventions:
                        Windows (/): {(getopt.AllowWindowsConventions ? "yes" : "no")}
                        Powershell (-): {(getopt.AllowPowershellConventions ? "yes" : "no")}
                        Gnu/Posix (-, --): yes
                    """
                );
            }
            sBuilder.AppendLine();
 
            var longestName = options.Max(o => o.Name?.Length ?? 0);
            // Align longestName to the next multiple of 4
            longestName = (longestName + 3) / 4 * 4;
 
            sBuilder.AppendLine("Switches:");
            foreach (var opt in options.Where(o => o.ArgumentType == ArgumentType.None)) {
                sBuilder.AppendLine(string.Format("{0}{1}{2}, {3}{4}{5}", Tab, shortOptPrefix, (char)opt.Value, longOptPrefix, opt.Name?.PadRight(longestName), opt.Description ?? string.Empty));
            }
            sBuilder.AppendLine();
 
            sBuilder.AppendLine("Options:");
            foreach (var opt in options.Where(o => o.ArgumentType != ArgumentType.None)) {
                var line = string.Format("{0}{1}{2}, {3}{4}{5}", Tab, shortOptPrefix, (char)opt.Value, longOptPrefix, opt.Name?.PadRight(longestName), opt.Description ?? string.Empty);
 
                // If line is > config.MaxWidth, split it into multiple lines and align the description
                if (line.Length > config.MaxWidth) {
                    var desc = opt.Description ?? string.Empty;
                    var beginWhitespace = new string(
                        ' ',
                        Tab.Length +
                        shortOptPrefix.Length +
                        1 +
                        longOptPrefix.Length +
                        (opt.Name?.PadRight(longestName).Length ?? 0) +
                        2 // these last two are the missing space and comma between the long and short opt
                    );
 
                    while (desc.Length > config.MaxWidth - longestName - 10) {
                        var split = desc.Substring(0, config.MaxWidth - longestName - 10);
                        var splitIndex = split.LastIndexOf(' ');
 
                        sBuilder.AppendLine(string.Format("{0}{1}", beginWhitespace, split.Substring(0, splitIndex)));
                        desc = desc.Substring(splitIndex + 1);
                    }
 
                    sBuilder.AppendLine(string.Format("{0}{1}{2}, {3}{4}{5}", Tab, shortOptPrefix, (char)opt.Value, longOptPrefix, opt.Name?.PadRight(longestName), desc));
                } else {
                    sBuilder.AppendLine(line);
                }
 
                sBuilder.AppendLine();
            }
            sBuilder.AppendLine();
 
            if (!string.IsNullOrEmpty(config.FooterText)) {
                sBuilder.AppendLine(config.FooterText);
            }
 
            return sBuilder.ToString();
        }
 
        public static string GetApplicationName() {
            return System.Reflection.Assembly.GetEntryAssembly()?.GetName().Name ?? "Unknown";
        }
 
    }
}