Пример #1
0
        /// <summary>
        /// Formats the help rows for a given option
        /// </summary>
        /// <param name="symbol"></param>
        /// <returns>A new <see cref="HelpItem"/></returns>
        protected virtual IEnumerable <HelpItem> OptionFormatter(ISymbol symbol)
        {
            var rawAliases = symbol.RawAliases
                             .OrderBy(alias => alias.Length);

            var option = string.Join(", ", rawAliases);

            if (symbol.ShouldShowHelp())
            {
                foreach (var argument in symbol.Arguments())
                {
                    if (!string.IsNullOrWhiteSpace(argument.Name))
                    {
                        var argumentDescriptor = ArgumentDescriptor(argument);
                        if (!string.IsNullOrWhiteSpace(argumentDescriptor))
                        {
                            option = $"{option} <{argumentDescriptor}>";
                        }
                    }
                }
            }

            yield return(new HelpItem
            {
                Invocation = option,
                Description = symbol.Description ?? ""
            });
        }
Пример #2
0
        /// <summary>
        /// Formats the help rows for a given option
        /// </summary>
        /// <param name="symbol"></param>
        /// <returns>A new <see cref="HelpItem"/></returns>
        private IEnumerable <HelpItem> GetOptionHelpItems(ISymbol symbol)
        {
            var rawAliases = symbol.RawAliases
                             .OrderBy(alias => alias.Length);

            var invocation = string.Join(", ", rawAliases);

            if (ShouldShowHelp(symbol))
            {
                foreach (var argument in symbol.Arguments())
                {
                    if (ShouldShowHelp(argument) &&
                        !string.IsNullOrWhiteSpace(argument.Name))
                    {
                        var argumentDescriptor = ArgumentDescriptor(argument);
                        if (!string.IsNullOrWhiteSpace(argumentDescriptor))
                        {
                            invocation = $"{invocation} <{argumentDescriptor}>";
                        }
                    }
                }
            }

            if (symbol is IOption option &&
                option.Required)
            {
                invocation += " (REQUIRED)";
            }

            yield return(new HelpItem(invocation, symbol.Description));
        }
Пример #3
0
        /// <summary>
        /// Formats the help rows for a given argument
        /// </summary>
        /// <param name="symbol"></param>
        /// <returns>A new <see cref="HelpItem"/></returns>
        private IEnumerable <HelpItem> GetArgumentHelpItems(ISymbol symbol)
        {
            foreach (var argument in symbol.Arguments())
            {
                if (ShouldShowHelp(argument))
                {
                    var argumentDescriptor = ArgumentDescriptor(argument);

                    var invocation = string.IsNullOrWhiteSpace(argumentDescriptor)
                                        ? ""
                                        : $"<{argumentDescriptor}>";

                    var argumentDescription = argument?.Description ?? "";
                    var defaultValueHint    = argument != null
                        ? BuildDefaultValueHint(argument)
                        : null;

                    yield return(new HelpItem(invocation, argumentDescription, defaultValueHint));
                }
            }

            string?BuildDefaultValueHint(IArgument argument)
            {
                var hint = DefaultValueHint(argument);

                return(!string.IsNullOrWhiteSpace(hint) ? $"[{hint}]" : null);
            }
        }
Пример #4
0
        internal int MaximumArgumentCapacity()
        {
            var value = 0;

            var arguments = Symbol.Arguments();

            for (var i = 0; i < arguments.Count; i++)
            {
                value += arguments[i].Arity.MaximumNumberOfValues;
            }

            return(value);
        }
Пример #5
0
        /// <summary>
        /// Formats the help rows for a given argument
        /// </summary>
        /// <param name="symbol"></param>
        /// <returns>A new <see cref="HelpItem"/></returns>
        protected virtual IEnumerable <HelpItem> ArgumentFormatter(ISymbol symbol)
        {
            foreach (var argument in symbol.Arguments())
            {
                var argumentDescriptor = ArgumentDescriptor(argument);

                yield return(new HelpItem
                {
                    Invocation = string.IsNullOrWhiteSpace(argumentDescriptor)
                                     ? ""
                                     : $"<{argumentDescriptor}>",
                    Description = argument?.Description ?? ""
                });
            }
        }
Пример #6
0
        /// <summary>
        /// Formats the help rows for a given argument
        /// </summary>
        /// <param name="symbol"></param>
        /// <returns>A new <see cref="HelpItem"/></returns>
        private IEnumerable <HelpItem> GetArgumentHelpItems(ISymbol symbol)
        {
            foreach (var argument in symbol.Arguments())
            {
                if (ShouldShowHelp(argument))
                {
                    var argumentDescriptor = ArgumentDescriptor(argument);

                    var invocation = string.IsNullOrWhiteSpace(argumentDescriptor)
                                        ? ""
                                        : $"<{argumentDescriptor}>";

                    var argumentDescription = argument?.Description ?? "";

                    yield return(new HelpItem(invocation, argumentDescription));
                }
            }
        }
        /// <summary>
        /// Formats the help rows for a given option
        /// </summary>
        /// <param name="symbol"></param>
        /// <returns>A new <see cref="HelpItem"/></returns>
        private IEnumerable <HelpItem> GetOptionHelpItems(ISymbol symbol)
        {
            var rawAliases = symbol
                             .RawAliases
                             .Select(r => r.SplitPrefix())
                             .OrderBy(r => r.prefix)
                             .ThenBy(r => r.alias)
                             .GroupBy(t => t.alias)
                             .Select(t => t.First())
                             .Select(t => $"{t.prefix}{t.alias}");

            var invocation = string.Join(", ", rawAliases);

            if (ShouldShowHelp(symbol))
            {
                foreach (var argument in symbol.Arguments())
                {
                    if (ShouldShowHelp(argument) &&
                        !string.IsNullOrWhiteSpace(argument.Name))
                    {
                        var argumentDescriptor = ArgumentDescriptor(argument);
                        if (!string.IsNullOrWhiteSpace(argumentDescriptor))
                        {
                            invocation = $"{invocation} <{argumentDescriptor}>";
                        }
                    }
                }
            }

            if (symbol is IOption option &&
                option.Required)
            {
                invocation += " (REQUIRED)";
            }

            yield return(new HelpItem(invocation, symbol.Description));
        }
Пример #8
0
 internal int MaximumArgumentCapacity() =>
 Symbol.Arguments()
 .Sum(a => a.Arity.MaximumNumberOfValues);
Пример #9
0
 internal static bool ShouldShowHelp(this ISymbol symbol) =>
 !symbol.IsHidden &&
 (!string.IsNullOrWhiteSpace(symbol.Name) ||
  !string.IsNullOrWhiteSpace(symbol.Description) ||
  symbol.Arguments().Any(a => a.ShouldShowHelp()));