public void CanReadHostDataFromITemplateInfo()
{
IEngineEnvironmentSettings engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
HostSpecificDataLoader hostSpecificDataLoader = new HostSpecificDataLoader(engineEnvironmentSettings);
Assert.True(engineEnvironmentSettings.TryGetMountPoint(Directory.GetCurrentDirectory(), out IMountPoint? mountPoint));
Assert.NotNull(mountPoint);
IFile?dataFile = mountPoint !.FileInfo("/Resources/dotnetcli.host.json");
Assert.NotNull(dataFile);
JObject json = ReadJObjectFromIFile(dataFile !);
ITemplateInfo template = A.Fake <ITemplateInfo>(builder => builder.Implements <ITemplateInfoHostJsonCache>().Implements <ITemplateInfo>());
A.CallTo(() => ((ITemplateInfoHostJsonCache)template).HostData).Returns(json);
HostSpecificTemplateData data = hostSpecificDataLoader.ReadHostSpecificTemplateData(template);
Assert.NotNull(data);
Assert.False(data.IsHidden);
Assert.Equal(2, data.UsageExamples?.Count);
Assert.Contains("--framework netcoreapp3.1 --langVersion '9.0'", data.UsageExamples);
Assert.Equal(4, data.SymbolInfo?.Count);
Assert.Contains("TargetFrameworkOverride", data.HiddenParameterNames);
Assert.Contains("Framework", data.ParametersToAlwaysShow);
Assert.True(data.LongNameOverrides.ContainsKey("skipRestore"));
Assert.Equal("no-restore", data.LongNameOverrides["skipRestore"]);
Assert.True(data.ShortNameOverrides.ContainsKey("skipRestore"));
Assert.Equal("", data.ShortNameOverrides["skipRestore"]);
Assert.Equal("no-restore", data.DisplayNameForParameter("skipRestore"));
}
internal static async Task <IEnumerable <TemplateGroup> > GetMatchingTemplateGroupsAsync(
InstantiateCommandArgs instantiateArgs,
TemplatePackageManager templatePackageManager,
HostSpecificDataLoader hostSpecificDataLoader,
CancellationToken cancellationToken)
{
var templates = await templatePackageManager.GetTemplatesAsync(cancellationToken).ConfigureAwait(false);
var templateGroups = TemplateGroup.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templates, hostSpecificDataLoader));
return(templateGroups.Where(template => template.ShortNames.Contains(instantiateArgs.ShortName)));
}
public void ReturnDefaultForInvalidEntry()
{
IEngineEnvironmentSettings engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
HostSpecificDataLoader hostSpecificDataLoader = new HostSpecificDataLoader(engineEnvironmentSettings);
ITemplateInfo template = A.Fake <ITemplateInfo>(builder => builder.Implements <ITemplateInfoHostJsonCache>().Implements <ITemplateInfo>());
A.CallTo(() => ((ITemplateInfoHostJsonCache)template).HostData).Returns(null);
HostSpecificTemplateData data = hostSpecificDataLoader.ReadHostSpecificTemplateData(template);
Assert.NotNull(data);
Assert.Equal(HostSpecificTemplateData.Default, data);
}
public void CreateDataForTemplatePack(IInstalledPackInfo packInfo, IReadOnlyList <ITemplateInfo> templateList, IEngineEnvironmentSettings environment)
{
IHostSpecificDataLoader hostDataLoader = new HostSpecificDataLoader(environment.SettingsLoader);
foreach (ITemplateInfo template in templateList)
{
HostSpecificTemplateData hostData = hostDataLoader.ReadHostSpecificTemplateData(template);
// store the host data if it has any info that could affect searching for this template.
if (hostData.IsHidden || hostData.SymbolInfo.Count > 0)
{
_hostDataForPackByTemplate[template.Identity] = hostData;
}
}
}
public void ReturnDefaultForInvalidFile()
{
IEngineEnvironmentSettings engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
HostSpecificDataLoader hostSpecificDataLoader = new HostSpecificDataLoader(engineEnvironmentSettings);
ITemplateInfo template = A.Fake <ITemplateInfo>();
A.CallTo(() => template.MountPointUri).Returns(Directory.GetCurrentDirectory());
A.CallTo(() => template.HostConfigPlace).Returns("unknown");
HostSpecificTemplateData data = hostSpecificDataLoader.ReadHostSpecificTemplateData(template);
Assert.NotNull(data);
Assert.Equal(HostSpecificTemplateData.Default, data);
}
protected internal override IEnumerable <CompletionItem> GetCompletions(CompletionContext context, IEngineEnvironmentSettings environmentSettings)
{
if (context is not TextCompletionContext textCompletionContext)
{
foreach (CompletionItem completion in base.GetCompletions(context, environmentSettings))
{
yield return(completion);
}
yield break;
}
InstantiateCommandArgs instantiateArgs = ParseContext(context.ParseResult);
using TemplatePackageManager templatePackageManager = new TemplatePackageManager(environmentSettings);
HostSpecificDataLoader?hostSpecificDataLoader = new HostSpecificDataLoader(environmentSettings);
//TODO: consider new API to get templates only from cache (non async)
IReadOnlyList <ITemplateInfo> templates =
Task.Run(async() => await templatePackageManager.GetTemplatesAsync(default).ConfigureAwait(false)).GetAwaiter().GetResult();
public static void WriteHelp(HelpContext context, InstantiateCommandArgs instantiateCommandArgs, IEngineEnvironmentSettings environmentSettings)
{
if (string.IsNullOrWhiteSpace(instantiateCommandArgs.ShortName))
{
WriteCustomInstantiateHelp(context, instantiateCommandArgs.Command);
return;
}
using TemplatePackageManager templatePackageManager = new TemplatePackageManager(environmentSettings);
HostSpecificDataLoader hostSpecificDataLoader = new HostSpecificDataLoader(environmentSettings);
//TODO: consider use cache only for help
var selectedTemplateGroups = Task.Run(
async() => await GetMatchingTemplateGroupsAsync(
instantiateCommandArgs,
templatePackageManager,
hostSpecificDataLoader,
default).ConfigureAwait(false))
.GetAwaiter()
.GetResult();
if (!selectedTemplateGroups.Any())
{
//help do not return error exit code, so we write error to StdOut instead
HandleNoMatchingTemplateGroup(instantiateCommandArgs, Reporter.Output);
return;
}
if (selectedTemplateGroups.Take(2).Count() > 1)
{
HandleAmbiguousTemplateGroup(environmentSettings, templatePackageManager, selectedTemplateGroups, Reporter.Output);
return;
}
TemplateGroup templateGroup = selectedTemplateGroups.Single();
IEnumerable <TemplateCommand> matchingTemplates =
GetMatchingTemplates(
instantiateCommandArgs,
environmentSettings,
templatePackageManager,
templateGroup);
if (!matchingTemplates.Any())
{
//output is handled in HandleNoTemplateFoundResult
HandleNoTemplateFoundResult(instantiateCommandArgs, environmentSettings, templatePackageManager, templateGroup, Reporter.Output);
return;
}
if (!VerifyMatchingTemplates(
environmentSettings,
matchingTemplates,
Reporter.Output,
out IEnumerable <TemplateCommand>?templatesToShow))
{
//error
//output is handled in VerifyMatchingTemplates
return;
}
var preferredTemplate = templatesToShow.OrderByDescending(x => x.Template.Precedence).First();
ShowTemplateDetailHeaders(preferredTemplate.Template, context.Output);
//we need to show all possible short names (not just the one specified)
ShowUsage(instantiateCommandArgs.Command, templateGroup.ShortNames, context);
ShowCommandOptions(templatesToShow, preferredTemplate, context);
ShowTemplateSpecificOptions(templatesToShow, context);
ShowHintForOtherTemplates(templateGroup, preferredTemplate.Template, instantiateCommandArgs, context.Output);
}
