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);
}
