/// <summary> /// Writes usage for the specified command. /// </summary> /// <param name="command">The command to write help details for.</param> /// <param name="writer">The writer to write help output to.</param> protected virtual void WriteCommandUsage(ICommand command, TextWriter writer) { string description = GetUsage(command); WriteHeading(LocalizationResources.HelpUsageTitle(), description, writer); writer.WriteLine(); }
/// <summary> /// Get a single resource /// </summary> /// <param name="resname">Name of the resource</param> /// <returns></returns> /// <author>Thomas Kosch</author> public static object GetResource(string resname) { if (LocalizationResources.ContainsKey(resname)) { return(LocalizationResources[resname]); } return(null); }
internal FailedArgumentTypeConversionResult( IArgument argument, Type expectedType, string value, LocalizationResources localizationResources) : base(argument, FormatErrorMessage(argument, expectedType, value, localizationResources)) { }
internal ArgumentConversionResult( Argument argument, Type expectedType, string value, LocalizationResources localizationResources) : this(argument, FormatErrorMessage(argument, expectedType, value, localizationResources), ArgumentConversionResultType.FailedType) { }
/// <param name="localizationResources">Resources used to localize the help output.</param> /// <param name="maxWidth">The maximum width in characters after which help output is wrapped.</param> public HelpBuilder(LocalizationResources localizationResources, int maxWidth = int.MaxValue) { LocalizationResources = localizationResources ?? throw new ArgumentNullException(nameof(localizationResources)); if (maxWidth <= 0) { maxWidth = int.MaxValue; } MaxWidth = maxWidth; }
/// <summary> /// Writes help output for additional arguments. /// </summary> protected virtual void WriteAdditionalArguments(ICommand command, TextWriter writer) { if (command.TreatUnmatchedTokensAsErrors) { return; } WriteHeading(LocalizationResources.HelpAdditionalArgumentsTitle(), LocalizationResources.HelpAdditionalArgumentsDescription(), writer); }
/// <summary> /// /// </summary> /// <param name="command">The command to get argument help items for.</param> /// <param name="parseResult">A parse result providing context for help formatting.</param> /// <param name="writer">The writer to write help output to.</param> protected virtual void WriteSubcommands(ICommand command, TextWriter writer, ParseResult parseResult) { var subcommands = GetSubcommandRows(command, parseResult).ToArray(); if (subcommands.Length > 0) { WriteHeading(LocalizationResources.HelpCommandsTitle(), null, writer); RenderAsColumns(writer, subcommands); writer.WriteLine(); } }
/// <summary> /// Writes help output for the specified command's arguments. /// </summary> /// <param name="command">The command to write out argument help for.</param> /// <param name="writer">The writer to write help output to.</param> /// <param name="parseResult">A parse result providing context for help formatting.</param> protected virtual void WriteCommandArguments(ICommand command, TextWriter writer, ParseResult parseResult) { TwoColumnHelpRow[] commandArguments = GetCommandArgumentRows(command, parseResult).ToArray(); if (commandArguments.Length > 0) { WriteHeading(LocalizationResources.HelpArgumentsTitle(), null, writer); RenderAsColumns(writer, commandArguments); writer.WriteLine(); } }
internal static ArgumentConversionResult ConvertObject( Argument argument, Type type, object?value, LocalizationResources localizationResources) { switch (value) { case Token singleValue: return(ConvertToken(argument, type, singleValue, localizationResources)); case IReadOnlyList <Token> manyValues: return(ConvertTokens(argument, type, manyValues, localizationResources)); default: return(None(argument)); } }
private static ArgumentConversionResult ConvertTokens( Argument argument, Type type, IReadOnlyList <Token> tokens, LocalizationResources localizationResources, ArgumentResult?argumentResult = null) { var itemType = type.GetElementTypeIfEnumerable() ?? typeof(string); var values = CreateEnumerable(type, itemType, tokens.Count); var isArray = values is Array; for (var i = 0; i < tokens.Count; i++) { var token = tokens[i]; var result = ConvertToken(argument, itemType, token, localizationResources); switch (result.Result) { case ArgumentConversionResultType.Successful: if (isArray) { values[i] = result.Value; } else { values.Add(result.Value); } break; default: // failures if (argumentResult is { Parent: CommandResult }) { argumentResult.OnlyTake(i); i = tokens.Count; break; } return(result); } }
/// <summary> /// Gets the usage for the specified command. /// </summary> /// <param name="command">The command to get usage for.</param> protected string GetUsage(ICommand command) { return(string.Join(" ", GetUsageParts().Where(x => !string.IsNullOrWhiteSpace(x)))); IEnumerable <string> GetUsageParts() { IEnumerable <ICommand> parentCommands = command .RecurseWhileNotNull(c => c.Parents.FirstOrDefaultOfType <ICommand>()) .Reverse(); foreach (ICommand parentCommand in parentCommands) { yield return(parentCommand.Name); yield return(FormatArgumentUsage(parentCommand.Arguments)); } var hasCommandWithHelp = command.Children .OfType <ICommand>() .Any(x => !x.IsHidden); if (hasCommandWithHelp) { yield return(LocalizationResources.HelpUsageCommandTitle()); } var displayOptionTitle = command.Options.Any(x => !x.IsHidden); if (displayOptionTitle) { yield return(LocalizationResources.HelpUsageOptionsTitle()); displayOptionTitle = false; } if (!command.TreatUnmatchedTokensAsErrors) { yield return(LocalizationResources.HelpUsageAdditionalArguments()); } } }
private static ArgumentConversionResult ConvertToken( Argument argument, Type type, Token token, LocalizationResources localizationResources) { var value = token.Value; if (type.TryGetNullableType(out var nullableType)) { return(ConvertToken(argument, nullableType, token, localizationResources)); } if (_stringConverters.TryGetValue(type, out var tryConvert)) { if (tryConvert(value, out var converted)) { return(Success(argument, converted)); } else { return(Failure(argument, type, value, localizationResources)); } } if (type.IsEnum) { try { return(Success(argument, Enum.Parse(type, value, true))); } catch (ArgumentException) { // TODO: find a way to do this without the try..catch } } return(Failure(argument, type, value, localizationResources)); }
private static string FormatErrorMessage( IArgument argument, Type expectedType, string value, LocalizationResources localizationResources) { if (argument is Argument a && a.Parents.Count == 1) { var firstParent = (IIdentifierSymbol)a.Parents[0]; var alias = firstParent.Aliases.First(); switch (firstParent) { case ICommand _: return(localizationResources.ArgumentConversionCannotParseForCommand(value, alias, expectedType)); case IOption _: return(localizationResources.ArgumentConversionCannotParseForOption(value, alias, expectedType)); } } return(localizationResources.ArgumentConversionCannotParse(value, expectedType)); }
public CustomHelpBuilder(IConsole console, LocalizationResources localizationResources, int maxWidth = int.MaxValue) : base(localizationResources, maxWidth) { Console = console; }
public ShoppingListLocalization() { Strings = new LocalizationResources(); }
/// <summary> /// Writes the synopsis for the specified command. /// </summary> /// <param name="command">The command to write help details for.</param> /// <param name="writer">The writer to write help output to.</param> protected virtual void WriteSynopsis(ICommand command, TextWriter writer) { WriteHeading(LocalizationResources.HelpDescriptionTitle(), command.Description, writer); writer.WriteLine(); }
public LocalizationResources BuildResources() { var data = new LocalizationResources(); foreach (var domainName in Options.Domains) { var domain = Context.LocalizeDomains.SingleOrDefault(d => d.Name == domainName); if (domain == null) { continue; } if (domain.Cultures == null) { continue; } // Retrieve cultures (no "'" allowed to prevent SQL Injection when using queries): var cultures = domain.Cultures.Replace('\'', '*').Split(',').Select(s => s.Trim()).Where(s => s.Length > 0).ToArray(); if (cultures.Length == 0) { continue; } // Create keys from queries: foreach (var query in Context.LocalizeQueries.Where(q => q.DomainId == domain.Id)) { using (var conn = new SqlConnection(Configuration.GetConnectionString(query.ConnectionName))) using (var cmd = conn.CreateCommand()) { cmd.CommandText = query.Sql .Replace("{cultures}", String.Join("','", cultures)); if (conn.State == System.Data.ConnectionState.Closed) { conn.Open(); } using (var reader = cmd.ExecuteReader()) { var keyCount = (reader.GetColumnSchema().Count - 1) / 2; while (reader.Read()) { var culture = reader.GetString(0); if (cultures.Contains(culture)) { for (int c = 0; c < keyCount; c++) { var key = reader.GetString(c * 2 + 1); var value = reader.GetString(c * 2 + 2); data.AddResourceValue(key, culture, value); } } } } } } // Create keys from keys: foreach (var key in Context.LocalizeKeys.Include(k => k.Values).Where(k => k.DomainId == domain.Id)) { var resource = new LocalizationResource(); resource.ForPath = key.ForPath; var namedParameters = (key.ParameterNames ?? "").Split(',').Select(s => s.Trim()).Where(s => s.Length > 0).ToArray(); foreach (var value in key.Values) { if (value.Value == null && value.Reviewed == false) { continue; } if (cultures.Contains(value.Culture)) { if (namedParameters.Length > 0) { for (int i = 0; i < namedParameters.Length; i++) { value.Value = (value.Value ?? "").Replace("{" + namedParameters[i], "{" + i); } } resource.Values[value.Culture] = (value.Value ?? ""); } } data.AddResource(key.Name, resource); } } return(data); }