private HashSet <string> GetReservedAliases() { HashSet <string> reservedAliases = new HashSet <string>(); foreach (string alias in this.Children.OfType <Option>().SelectMany(o => o.Aliases)) { reservedAliases.Add(alias); } foreach (string alias in this.Children.OfType <Command>().SelectMany(o => o.Aliases)) { reservedAliases.Add(alias); } //add options of parent? - this covers debug: options foreach (string alias in _instantiateCommand.Children.OfType <Option>().SelectMany(o => o.Aliases)) { reservedAliases.Add(alias); } foreach (string alias in _instantiateCommand.Children.OfType <Command>().SelectMany(o => o.Aliases)) { reservedAliases.Add(alias); } //add restricted aliases: language, type, baseline (they may be optional) foreach (string alias in new[] { SharedOptionsFactory.CreateLanguageOption(), SharedOptionsFactory.CreateTypeOption(), SharedOptionsFactory.CreateBaselineOption() }.SelectMany(o => o.Aliases)) { reservedAliases.Add(alias); } foreach (string helpAlias in KnownHelpAliases) { reservedAliases.Add(helpAlias); } return(reservedAliases); }
private static void HandleNoMatchOnTemplateBaseOptions(IEnumerable <TemplateResult> matchInfos, InstantiateCommandArgs args, TemplateGroup templateGroup) { Option <string> languageOption = SharedOptionsFactory.CreateLanguageOption(); Option <string> typeOption = SharedOptionsFactory.CreateTypeOption(); Option <string> baselineOption = SharedOptionsFactory.CreateBaselineOption(); Command reparseCommand = new Command("reparse-only") { languageOption, typeOption, baselineOption, new Argument <string[]>("rem-args") { Arity = new ArgumentArity(0, 999) } }; ParseResult result = ParserFactory.CreateParser(reparseCommand).Parse(args.RemainingArguments ?? Array.Empty <string>()); string baseInputParameters = $"'{args.ShortName}'"; foreach (var option in new[] { languageOption, typeOption, baselineOption }) { if (result.FindResultFor(option) is { } optionResult&& optionResult.Token is { } token) { baseInputParameters = baseInputParameters + $", {token.Value}='{optionResult.GetValueOrDefault<string>()}'"; } } Reporter.Error.WriteLine(string.Format(LocalizableStrings.NoTemplatesMatchingInputParameters, baseInputParameters).Bold().Red()); foreach (var option in new[] { new { Option = languageOption, Condition = matchInfos.All(mi => !mi.IsLanguageMatch), AllowedValues = templateGroup.Languages }, new { Option = typeOption, Condition = matchInfos.All(mi => !mi.IsTypeMatch), AllowedValues = templateGroup.Types }, new { Option = baselineOption, Condition = matchInfos.All(mi => !mi.IsBaselineMatch), AllowedValues = (IReadOnlyList <string?>)templateGroup.Baselines }, }) { if (option.Condition && result.FindResultFor(option.Option) is { } optionResult&& optionResult.Token is { } token) { string allowedValues = string.Join(", ", option.AllowedValues.Select(l => $"'{l}'").OrderBy(l => l, StringComparer.OrdinalIgnoreCase)); Reporter.Error.WriteLine(string.Format(LocalizableStrings.TemplateOptions_Error_AllowedValuesForOptionList, token.Value, allowedValues)); } } Reporter.Error.WriteLine(); Reporter.Error.WriteLine(LocalizableStrings.ListTemplatesCommand); Reporter.Error.WriteCommand( Example .For <NewCommand>(args.ParseResult) .WithSubcommand <ListCommand>()); Reporter.Error.WriteLine(LocalizableStrings.SearchTemplatesCommand); Reporter.Error.WriteCommand( Example .For <NewCommand>(args.ParseResult) .WithSubcommand <SearchCommand>() .WithArgument(SearchCommand.NameArgument, args.ShortName ?? string.Empty)); Reporter.Error.WriteLine(); }
private static string?ParseOutputOption(ParseResult commandParseResult) { Option <string> outputOption = SharedOptionsFactory.CreateOutputOption(); Command helperCommand = new Command("parse-output") { outputOption }; ParseResult reparseResult = ParserFactory .CreateParser(helperCommand, disableHelp: true) .Parse(commandParseResult.Tokens.Select(t => t.Value).ToArray()); return(reparseResult.GetValueForOption <string>(outputOption)); }
internal static void ShowHintForOtherTemplates(TemplateGroup templateGroup, CliTemplateInfo preferredtemplate, InstantiateCommandArgs args, TextWriter writer) { //other languages if (templateGroup.Languages.Count <= 1) { return; } string?preferredLanguage = preferredtemplate.GetLanguage(); List <string> supportedLanguages = new List <string>(); foreach (string?language in templateGroup.Languages) { if (string.IsNullOrWhiteSpace(language)) { continue; } if (!language.Equals(preferredLanguage, StringComparison.OrdinalIgnoreCase)) { supportedLanguages.Add(language); } } if (!supportedLanguages.Any()) { return; } supportedLanguages.Sort(StringComparer.OrdinalIgnoreCase); writer.WriteLine(HelpStrings.Hint_HelpForOtherLanguages, string.Join(", ", supportedLanguages)); writer.WriteLine( Example .For <NewCommand>(args.ParseResult) .WithArgument(NewCommand.ShortNameArgument, templateGroup.ShortNames[0]) .WithHelpOption() .WithOption(SharedOptionsFactory.CreateLanguageOption(), supportedLanguages.First()) .ToString().Indent()); writer.WriteLine(); //other types if (templateGroup.Types.Count <= 1) { return; } string?preferredType = preferredtemplate.GetTemplateType(); List <string> supportedTypes = new List <string>(); foreach (string?type in templateGroup.Types) { if (string.IsNullOrWhiteSpace(type)) { continue; } if (!type.Equals(preferredType, StringComparison.OrdinalIgnoreCase)) { supportedTypes.Add(type); } } if (!supportedTypes.Any()) { return; } supportedTypes.Sort(StringComparer.OrdinalIgnoreCase); writer.WriteLine(HelpStrings.Hint_HelpForOtherTypes, string.Join(", ", supportedTypes)); writer.WriteLine(Example .For <NewCommand>(args.ParseResult) .WithArgument(NewCommand.ShortNameArgument, templateGroup.ShortNames[0]) .WithHelpOption() .WithOption(SharedOptionsFactory.CreateTypeOption(), supportedTypes.First()) .ToString().Indent()); writer.WriteLine(); }
/// <summary> /// Create command for instantiation of specific template. /// </summary> /// <exception cref="InvalidTemplateParametersException">when <paramref name="template"/> has invalid template parameters.</exception> public TemplateCommand( BaseCommand instantiateCommand, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager, TemplateGroup templateGroup, CliTemplateInfo template, bool buildDefaultLanguageValidation = false) : base( templateGroup.ShortNames[0], template.Name + Environment.NewLine + template.Description) { _instantiateCommand = instantiateCommand; _environmentSettings = environmentSettings; _templatePackageManager = templatePackageManager; _templateGroup = templateGroup; _template = template; foreach (var item in templateGroup.ShortNames.Skip(1)) { AddAlias(item); } this.AddOption(OutputOption); this.AddOption(NameOption); this.AddOption(DryRunOption); this.AddOption(ForceOption); this.AddOption(NoUpdateCheckOption); string?templateLanguage = template.GetLanguage(); string?defaultLanguage = environmentSettings.GetDefaultLanguage(); if (!string.IsNullOrWhiteSpace(templateLanguage)) { LanguageOption = SharedOptionsFactory.CreateLanguageOption(); LanguageOption.Description = SymbolStrings.TemplateCommand_Option_Language; LanguageOption.FromAmongCaseInsensitive(new[] { templateLanguage }); if (!string.IsNullOrWhiteSpace(defaultLanguage) && buildDefaultLanguageValidation) { LanguageOption.SetDefaultValue(defaultLanguage); LanguageOption.AddValidator(optionResult => { var value = optionResult.GetValueOrDefault <string>(); if (value != template.GetLanguage()) { optionResult.ErrorMessage = "Languages don't match"; } } ); } this.AddOption(LanguageOption); } string?templateType = template.GetTemplateType(); if (!string.IsNullOrWhiteSpace(templateType)) { TypeOption = SharedOptionsFactory.CreateTypeOption(); TypeOption.Description = SymbolStrings.TemplateCommand_Option_Type; TypeOption.FromAmongCaseInsensitive(new[] { templateType }); this.AddOption(TypeOption); } if (template.BaselineInfo.Any(b => !string.IsNullOrWhiteSpace(b.Key))) { BaselineOption = SharedOptionsFactory.CreateBaselineOption(); BaselineOption.Description = SymbolStrings.TemplateCommand_Option_Baseline; BaselineOption.FromAmongCaseInsensitive(template.BaselineInfo.Select(b => b.Key).Where(b => !string.IsNullOrWhiteSpace(b)).ToArray()); this.AddOption(BaselineOption); } if (HasRunScriptPostActionDefined(template)) { AllowScriptsOption = new Option <AllowRunScripts>("--allow-scripts") { Description = SymbolStrings.TemplateCommand_Option_AllowScripts, Arity = new ArgumentArity(1, 1) }; AllowScriptsOption.SetDefaultValue(AllowRunScripts.Prompt); this.AddOption(AllowScriptsOption); } AddTemplateOptionsToCommand(template); }