private IEnumerable <TemplateSearchData> TryGetTemplatesInPack(IDownloadedPackInfo packInfo, IReadOnlyList <IAdditionalDataProducer> additionalDataProducers) { ITemplateEngineHost host = TemplateEngineHostHelper.CreateHost(HostIdentifierBase + packInfo.Name); using EngineEnvironmentSettings environmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true); Scanner scanner = new Scanner(environmentSettings); try { using var scanResult = scanner.Scan(packInfo.Path, scanForComponents: false); if (scanResult.Templates.Any()) { foreach (IAdditionalDataProducer dataProducer in additionalDataProducers) { #pragma warning disable CS0612 // Type or member is obsolete dataProducer.CreateDataForTemplatePack(packInfo, scanResult.Templates, environmentSettings); #pragma warning restore CS0612 // Type or member is obsolete } return(scanResult.Templates.Select(t => new TemplateSearchData(t, t.ProduceAdditionalData(additionalDataProducers, environmentSettings)))); } return(Array.Empty <TemplateSearchData>()); } catch (TaskCanceledException) { throw; } catch (Exception ex) { Console.WriteLine("Failed to read package {0}::{1}, details: {2}. The package will be skipped.", packInfo.Name, packInfo.Version, ex); return(Array.Empty <TemplateSearchData>()); } }
/// <summary> /// Creates the instance. /// </summary> /// <param name="host">caller <see cref="ITemplateEngineHost"/>.</param> /// <param name="virtualizeConfiguration">if true, settings will be stored in memory and will be disposed with instance.</param> /// <param name="loadDefaultComponents">if true, the default components (providers, installers, generator) will be loaded. Same as calling <see cref="LoadDefaultComponents()"/> after instance is created.</param> /// <param name="hostSettingsLocation">the file path to store host specific settings. Use null for default location. /// Note: this parameter changes only directory of host and host version specific settings. Global settings path remains unchanged.</param> public Bootstrapper(ITemplateEngineHost host, bool virtualizeConfiguration, bool loadDefaultComponents = true, string?hostSettingsLocation = null) { _host = host ?? throw new ArgumentNullException(nameof(host)); if (string.IsNullOrWhiteSpace(hostSettingsLocation)) { _engineEnvironmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: virtualizeConfiguration); } else { string hostSettingsDir = Path.Combine(hostSettingsLocation, host.HostIdentifier); string hostVersionSettingsDir = Path.Combine(hostSettingsLocation, host.HostIdentifier, host.Version); IEnvironment environment = new DefaultEnvironment(); IPathInfo pathInfo = new DefaultPathInfo(environment, host, hostSettingsDir: hostSettingsDir, hostVersionSettingsDir: hostVersionSettingsDir); _engineEnvironmentSettings = new EngineEnvironmentSettings( host, virtualizeSettings: virtualizeConfiguration, environment: environment, pathInfo: pathInfo); } _templateCreator = new TemplateCreator(_engineEnvironmentSettings); _templatePackagesManager = new Edge.Settings.TemplatePackageManager(_engineEnvironmentSettings); if (loadDefaultComponents) { LoadDefaultComponents(); } }
private CodeGen(string locationId, string hostVersion) { var host = CreateHost(locationId, hostVersion); Settings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x)); Creator = new TemplateCreator(Settings); }
private void TryCleanup(EngineEnvironmentSettings environment) { Paths paths = new Paths(environment); try { paths.Delete(paths.User.BaseDir); } catch { // do nothing. } // remove the temporary hive string hiveDir = Directory.GetParent(paths.User.BaseDir).FullName; try { paths.Delete(hiveDir); } catch { // do nothing. } }
internal void CanParseMultiChoiceTemplateOptions(string command, string parameterName, string parameterValues, string?defaultIfNoOptionValue, string?expectedValue) { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithChoiceParameter(parameterName, parameterValues.Split("|"), defaultIfNoOptionValue: defaultIfNoOptionValue, allowMultipleValues: true); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new {command}"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); Parser parser = ParserFactory.CreateParser(templateCommand); ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty <string>()); var templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult); if (string.IsNullOrWhiteSpace(expectedValue)) { Assert.False(templateArgs.TemplateParameters.ContainsKey(parameterName)); } else { Assert.True(templateArgs.TemplateParameters.ContainsKey(parameterName)); Assert.Equal(expectedValue, templateArgs.TemplateParameters[parameterName]); } }
public ScrapeComparer(ComparisonConfig config) { _config = config; ITemplateEngineHost host = TemplateEngineHostHelper.CreateHost("Comparison"); _environmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true); }
public Task FailedToResolveTemplate_WhenMultipleLanguagesAreFound() { IReadOnlyList <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>() { new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L1", groupIdentity: "Console.App.Test").WithTag("language", "L1"), new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L2", groupIdentity: "Console.App.Test").WithTag("language", "L2"), new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L3", groupIdentity: "Console.App.Test").WithTag("language", "L3") }; TemplateGroup templateGroup = TemplateGroup.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templatesToSearch, A.Fake <IHostSpecificDataLoader>())).Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new console"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(3, matchingTemplates.Count()); StringWriter output = new StringWriter(); Reporter reporter = new Reporter(new AnsiConsole(output)); Assert.False(InstantiateCommand.VerifyMatchingTemplates(settings, matchingTemplates, reporter, out _)); return(Verifier.Verify(output.ToString(), _verifySettings.Settings)); }
public void HasTypeMismatch_HasGroupLanguageMatch() { List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>(); templatesToSearch.Add( new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T1", groupIdentity: "Console.App.Test") .WithTag("language", "L1") .WithTag("type", "project") .WithBaselineInfo("app", "standard")); templatesToSearch.Add( new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.T2", groupIdentity: "Console.App.Test") .WithTag("language", "L2") .WithTag("type", "project") .WithBaselineInfo("app", "standard")); TemplateGroup templateGroup = TemplateGroup.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templatesToSearch, A.Fake <IHostSpecificDataLoader>())).Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new console --language L2 --type item"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(0, matchingTemplates.Count()); }
public TemplateEngineHost() : base(VSHost, FindTemplateHostVersion(), VSHostLocale) { MountPointFactory = new FileSystemMountPointFactory(); Settings = new EngineEnvironmentSettings(this, settings => new TemplateSettingsLoader(settings)); Orchestrator = new RunnableProjectOrchestrator(new Orchestrator()); TemplateCreator = new TemplateCreator(Settings); Generator = new RunnableProjectGenerator(); MountPointManager = new MountPointManager(Settings, ComponentManager); HostDefaults = new Dictionary <string, string> { ["HostIdentifier"] = HostIdentifier, ["Locale"] = Locale, ["Version"] = Version }; UserTemplates = SettingsLoader.UserTemplateCache.TemplateInfo; MountPoints = new List <IMountPoint>(); foreach (var mountPointInfo in SettingsLoader.MountPoints) { if (MountPointFactory.TryMount(MountPointManager, mountPointInfo, out var mountPoint)) { MountPoints.Add(mountPoint); } } }
public PackCheckResult TryGetTemplatesInPack(IDownloadedPackInfo packInfo, IReadOnlyList <IAdditionalDataProducer> additionalDataProducers, HashSet <string> alreadySeenTemplateIdentities) { ITemplateEngineHost host = CreateHost(packInfo); using EngineEnvironmentSettings environmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true); PackCheckResult checkResult; try { if (TryInstallPackage(packInfo.Path, environmentSettings, out IReadOnlyList <ITemplateInfo> installedTemplates)) { IReadOnlyList <ITemplateInfo> filteredInstalledTemplates = installedTemplates.Where(t => !alreadySeenTemplateIdentities.Contains(t.Identity)).ToList(); checkResult = new PackCheckResult(packInfo, filteredInstalledTemplates); ProduceAdditionalDataForPack(additionalDataProducers, checkResult, environmentSettings); } else { IReadOnlyList <ITemplateInfo> foundTemplates = new List <ITemplateInfo>(); checkResult = new PackCheckResult(packInfo, foundTemplates); } } catch { IReadOnlyList <ITemplateInfo> foundTemplates = new List <ITemplateInfo>(); checkResult = new PackCheckResult(packInfo, foundTemplates); } return(checkResult); }
public void CanCompleteTypes() { var template1 = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithTag("type", "project"); var template2 = new MockTemplateInfo("foo", identity: "foo.2", groupIdentity: "foo.group") .WithTag("type", "solution"); var templateGroups = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template1, template2 }, A.Fake <IHostSpecificDataLoader>())); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new foo --type "); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var completionContext = parseResult.GetCompletionContext() as TextCompletionContext; Assert.NotNull(completionContext); var result = InstantiateCommand.GetTemplateCompletions(args, templateGroups, settings, packageManager, completionContext !).Select(l => l.Label); Assert.Equal(new[] { "project", "solution" }, result); }
public Task CanShowTemplateOptions_MultipleTemplate_MultipleParams() { var template1 = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group", precedence: 0) .WithChoiceParameter("choice", new[] { "val1", "val2" }, description: "my description", defaultValue: "def-val-not-shown", defaultIfNoOptionValue: "def-val-not-shown") .WithParameter("bool", paramType: "boolean", description: "my bool", defaultValue: "false", defaultIfNoOptionValue: "false"); var template2 = new MockTemplateInfo("foo", identity: "foo.2", groupIdentity: "foo.group", precedence: 2) .WithChoiceParameter("choice", new[] { "val1", "val3" }, description: "my description", defaultValue: "def-val", defaultIfNoOptionValue: "def-val-no-arg") .WithParameter("int", paramType: "integer", description: "my int", defaultValue: "0", defaultIfNoOptionValue: "10"); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template1, template2 }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); TemplateCommand templateCommand1 = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[0]); TemplateCommand templateCommand2 = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[1]); StringWriter sw = new StringWriter(); HelpContext helpContext = new HelpContext(new HelpBuilder(LocalizationResources.Instance), myCommand, sw); InstantiateCommand.ShowTemplateSpecificOptions(new[] { templateCommand2, templateCommand1 }, helpContext); return(Verifier.Verify(sw.ToString(), _verifySettings.Settings)); }
internal void Create_CanEvaluateTemplateToRun(string command, string templateSet, string?defaultLanguage, string?expectedIdentitiesStr) { TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(_testSets[templateSet], A.Fake <IHostSpecificDataLoader>())) .Single(); string[] expectedIdentities = expectedIdentitiesStr?.Split("|") ?? Array.Empty <string>(); var defaultParams = new Dictionary <string, string>(); if (defaultLanguage != null) { defaultParams["prefs:language"] = defaultLanguage; } ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($"new create {command}"); var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command; var args = new InstantiateCommandArgs(instantiateCommand, parseResult); var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(expectedIdentities.Count(), templateCommands.Count); Assert.Equal(expectedIdentities.OrderBy(s => s), templateCommands.Select(templateCommand => templateCommand.Template.Identity).OrderBy(s => s)); }
public ScrapeComparer(ComparisonConfig config) { _config = config; ITemplateEngineHost host = TemplateEngineHostHelper.CreateHost("Comparison"); _environmentSettings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x)); }
internal void Create_CanDetectParseErrorsChoiceTemplateOptions( string command, string parameterName, string parameterValues, bool isRequired, string?defaultValue, string?defaultIfNoOptionValue, string expectedError) { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithChoiceParameter(parameterName, parameterValues.Split("|"), isRequired, defaultValue, defaultIfNoOptionValue); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new create {command}"); var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command; var args = new InstantiateCommandArgs(instantiateCommand, parseResult); TemplateCommand templateCommand = new TemplateCommand(instantiateCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); Parser parser = ParserFactory.CreateParser(templateCommand); ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty <string>()); Assert.True(templateParseResult.Errors.Any()); Assert.Equal(expectedError, templateParseResult.Errors.Single().Message); }
public void DefaultLanguageDisambiguates() { List <ITemplateInfo> templatesToSearch = new List <ITemplateInfo>(); templatesToSearch.Add(new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L1", groupIdentity: "Console.App.Test").WithTag("language", "L1")); templatesToSearch.Add(new MockTemplateInfo("console", name: "Long name for Console App", identity: "Console.App.L2", groupIdentity: "Console.App.Test").WithTag("language", "L2")); TemplateGroup templateGroup = TemplateGroup.FromTemplateList(CliTemplateInfo.FromTemplateInfo(templatesToSearch, A.Fake <IHostSpecificDataLoader>())).Single(); var defaultParams = new Dictionary <string, string>(); defaultParams["prefs:language"] = "L1"; ITemplateEngineHost host = TestHost.GetVirtualHost(defaultParameters: defaultParams); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new console"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Equal(2, matchingTemplates.Count()); StringWriter output = new StringWriter(); Reporter reporter = new Reporter(new AnsiConsole(output)); Assert.True(InstantiateCommand.VerifyMatchingTemplates(settings, matchingTemplates, reporter, out IEnumerable <TemplateCommand>?filtered)); Assert.Equal(1, filtered?.Count()); Assert.Equal("Console.App.L1", filtered?.Single().Template.Identity); Assert.Empty(output.ToString()); }
internal void CanParseAllowScriptsOption(string command, AllowRunScripts?result) { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithPostActions(ProcessStartPostActionProcessor.ActionProcessorId); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse(command); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); TemplateCommand templateCommand = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); Parser parser = ParserFactory.CreateParser(templateCommand); ParseResult templateParseResult = parser.Parse(args.RemainingArguments ?? Array.Empty <string>()); TemplateCommandArgs templateArgs = new TemplateCommandArgs(templateCommand, myCommand, templateParseResult); Assert.Equal(result, templateArgs.AllowScripts); }
private ITemplateEngineHost LoadHostWithLocalizationTemplates(out SettingsLoader settingsLoaderOut) { var thisDir = Path.GetDirectoryName(typeof(LocalizationTests).Assembly.Location); var testTemplatesFolder = Path.Combine(thisDir, "..", "..", "..", "..", "..", "test", "Microsoft.TemplateEngine.TestTemplates", "test_templates", "TemplateWithLocalization"); testTemplatesFolder = new DirectoryInfo(testTemplatesFolder).FullName; ITemplateEngineHost host = new TestHost { HostIdentifier = "TestRunner", Version = "1.0.0.0", Locale = "en-US", FallbackHostTemplateConfigNames = Array.Empty <string>(), }; SettingsLoader settingsLoader = null; var envSettings = new EngineEnvironmentSettings(host, x => settingsLoader = new SettingsLoader(x)); host.VirtualizeDirectory(Path.Combine(Environment.ExpandEnvironmentVariables("%USERPROFILE%"), ".templateengine", "TestRunner")); settingsLoader.Components.Register(typeof(RunnableProjectGenerator)); settingsLoader.UserTemplateCache.Scan(testTemplatesFolder); settingsLoader.Save(); settingsLoaderOut = settingsLoader; return(host); }
internal static Func <IDownloadedPackInfo, PreFilterResult> SetupPackFilter() { Func <IDownloadedPackInfo, PreFilterResult> filter = (packInfo) => { using EngineEnvironmentSettings environmentSettings = new EngineEnvironmentSettings(_host, virtualizeSettings: true); foreach (IMountPointFactory factory in environmentSettings.Components.OfType <IMountPointFactory>()) { if (factory.TryMount(environmentSettings, null, packInfo.Path, out IMountPoint? mountPoint)) { bool hasTemplateJson = mountPoint !.Root.EnumerateFiles("template.json", SearchOption.AllDirectories).Any(); mountPoint.Dispose(); if (hasTemplateJson) { return(new PreFilterResult(_FilterId, isFiltered: false)); } break; // this factory mounted the pack. No more checking is needed. } } return(new PreFilterResult(_FilterId, isFiltered: true, "Package did not contain any template.json files")); }; return(filter); }
public PackCheckResult TryGetTemplatesInPack(IInstalledPackInfo packInfo, IReadOnlyList <IAdditionalDataProducer> additionalDataProducers, HashSet <string> alreadySeenTemplateIdentities, bool persistHive = false) { ITemplateEngineHost host = CreateHost(packInfo); EngineEnvironmentSettings environment = new EngineEnvironmentSettings(host, x => new SettingsLoader(x)); PackCheckResult checkResult; try { if (TryInstallPackage(packInfo.Path, environment, out IReadOnlyList <ITemplateInfo> installedTemplates)) { IReadOnlyList <ITemplateInfo> filteredInstalledTemplates = installedTemplates.Where(t => !alreadySeenTemplateIdentities.Contains(t.Identity)).ToList(); checkResult = new PackCheckResult(packInfo, filteredInstalledTemplates); ProduceAdditionalDataForPack(additionalDataProducers, checkResult, environment); } else { IReadOnlyList <ITemplateInfo> foundTemplates = new List <ITemplateInfo>(); checkResult = new PackCheckResult(packInfo, foundTemplates); } } catch { IReadOnlyList <ITemplateInfo> foundTemplates = new List <ITemplateInfo>(); checkResult = new PackCheckResult(packInfo, foundTemplates); } if (!persistHive) { TryCleanup(environment); } return(checkResult); }
void Initialize() { host = new CustomTemplateEngineHost(); settings = new EngineEnvironmentSettings(host, s => new SettingsLoader(s)); paths = new Paths(settings); templateCreator = new TemplateCreator(settings); DeleteCache(); }
public void NupkgReinstallDoesntRemoveTemplates() { const string nupkgToInstallName = "TestNupkgInstallTemplate.0.0.1.nupkg"; const string checkTemplateName = "nupkginstall"; // this is the short name of the template in the nupkg that gets installed. ITemplateEngineHost host = CreateHostWithVirtualizedHive(HostIdentifier, HostVersion); Assert.NotNull(host); ITelemetryLogger telemetryLogger = new TelemetryLogger(null, false); int initializeResult = New3Command.Run(CommandName, host, telemetryLogger, null, new string[] { }); Assert.Equal(0, initializeResult); string codebase = typeof(NupkgInstallTests).GetTypeInfo().Assembly.CodeBase; Uri cb = new Uri(codebase); string asmPath = cb.LocalPath; string dir = Path.GetDirectoryName(asmPath); string pathToInstall = Path.Combine(dir, "TemplateInstallTests", "TestTemplates", nupkgToInstallName); Assert.True(File.Exists(pathToInstall), $"directory didnt exist: {pathToInstall}"); string[] installArgs = new[] { "--install", pathToInstall }; // install the test pack int firstInstallResult = New3Command.Run(CommandName, host, telemetryLogger, null, installArgs); Assert.Equal(0, firstInstallResult); EngineEnvironmentSettings environemnt = new EngineEnvironmentSettings(host, x => new SettingsLoader(x)); SettingsLoader settingsLoader = (SettingsLoader)environemnt.SettingsLoader; IHostSpecificDataLoader hostDataLoader = new MockHostSpecificDataLoader(); // check that the template was installed from the first install. IReadOnlyCollection <ITemplateMatchInfo> allTemplates = TemplateListResolver.PerformAllTemplatesQuery(settingsLoader.UserTemplateCache.TemplateInfo, hostDataLoader); Assert.Contains(checkTemplateName, allTemplates.Select(t => t.Info.ShortName)); // install the same test pack again int secondInstallResult = New3Command.Run(CommandName, host, telemetryLogger, null, installArgs); Assert.Equal(0, secondInstallResult); settingsLoader.Reload(); // check that the template is still installed after the second install. IReadOnlyCollection <ITemplateMatchInfo> allTemplatesAfterSecondInstall = TemplateListResolver.PerformAllTemplatesQuery(settingsLoader.UserTemplateCache.TemplateInfo, hostDataLoader); Assert.Contains(checkTemplateName, allTemplatesAfterSecondInstall.Select(t => t.Info.ShortName)); }
protected TestBase() { ITemplateEngineHost host = new TestHost { HostIdentifier = "TestRunner", Version = "1.0.0.0", Locale = "en-US" }; EnvironmentSettings = new EngineEnvironmentSettings(host, s => null); host.VirtualizeDirectory(Environment.ExpandEnvironmentVariables("%USERPROFILE%/.templateengine")); }
public Bootstrapper(ITemplateEngineHost host, Action <IEngineEnvironmentSettings, IInstaller> onFirstRun, bool virtualizeConfiguration) { _host = host; EnvironmentSettings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x)); Installer = new Installer(EnvironmentSettings); _onFirstRun = onFirstRun; _paths = new Paths(EnvironmentSettings); _templateCreator = new TemplateCreator(EnvironmentSettings); if (virtualizeConfiguration) { EnvironmentSettings.Host.VirtualizeDirectory(_paths.User.BaseDir); } }
public New3Command(string commandName, ITemplateEngineHost host, Action <IEngineEnvironmentSettings, IInstaller> onFirstRun, ExtendedCommandParser app, CommandArgument templateName) { host = new ExtendedTemplateEngineHost(host, this); EnvironmentSettings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x)); Installer = new Installer(EnvironmentSettings); _templateCreator = new TemplateCreator(EnvironmentSettings); _templateCache = new TemplateCache(EnvironmentSettings); _aliasRegistry = new AliasRegistry(EnvironmentSettings); CommandName = commandName; _paths = new Paths(EnvironmentSettings); _app = app; _templateNameArgument = templateName; _onFirstRun = onFirstRun; }
protected IEngineEnvironmentSettings CreateEnvironmentSettings(GlobalArgs args, ParseResult parseResult) { //reparse to get output option if present //it's kept private so it is not reused for any other purpose except initializing host //for template instantiaton it has to be reparsed string?outputPath = ParseOutputOption(parseResult); IEngineEnvironmentSettings environmentSettings = new EngineEnvironmentSettings( new CliTemplateEngineHost(_hostBuilder(parseResult), outputPath), settingsLocation: args.DebugCustomSettingsLocation, virtualizeSettings: args.DebugVirtualizeSettings, environment: new CliEnvironment()); return(environmentSettings); }
private EngineEnvironmentSettings GetEngineEnvironmentSettings() { var envSettings = new EngineEnvironmentSettings( new DefaultTemplateEngineHost("Initializr", "v1.0", string.Empty), (IEngineEnvironmentSettings settings) => new InitializrSettingsLoader(settings, _hivePath), _hivePath); var cachePath = Path.Combine(_hivePath, "templatecache.json"); if (!File.Exists(cachePath)) { Console.WriteLine("File doesnt exist " + cachePath); ((InitializrSettingsLoader)envSettings.SettingsLoader).RebuildCacheFromSettingsIfNotCurrent(true); } return(envSettings); }
private bool TryInstallPackage(string packageFile, EngineEnvironmentSettings environment, out IReadOnlyList <ITemplateInfo> installedTemplates) { ((SettingsLoader)(environment.SettingsLoader)).UserTemplateCache.Scan(packageFile); environment.SettingsLoader.Save(); if (((SettingsLoader)environment.SettingsLoader).UserTemplateCache.TemplateInfo.Count > 0) { installedTemplates = ((SettingsLoader)environment.SettingsLoader).UserTemplateCache.TemplateInfo; } else { installedTemplates = new List <ITemplateInfo>(); } return(installedTemplates.Count > 0); }
public Task CannotCreateCommandForInvalidParameter() { var template = new MockTemplateInfo("foo", identity: "foo.1", groupIdentity: "foo.group") .WithParameters("have:colon", "n1", "n2"); var paramSymbolInfo = new Dictionary <string, string>() { { "longName", "name" }, { "shortName", "n" } }; var symbolInfo = new Dictionary <string, IReadOnlyDictionary <string, string> > { { "n1", paramSymbolInfo }, { "n2", paramSymbolInfo } }; var hostDataLoader = A.Fake <IHostSpecificDataLoader>(); A.CallTo(() => hostDataLoader.ReadHostSpecificTemplateData(template)).Returns(new HostSpecificTemplateData(symbolInfo)); TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(new[] { template }, hostDataLoader)) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager packageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new foo"); InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); try { _ = new TemplateCommand(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single()); } catch (InvalidTemplateParametersException e) { Assert.Equal(2, e.ParameterErrors.Count); Assert.Equal(templateGroup.Templates.Single(), e.Template); return(Verifier.Verify(e.Message, _verifySettings.Settings)); } Assert.True(false, "should not land here"); return(Task.FromResult(1)); }
// invalid params: // [0] name / value - Kind // [1] canonical // [2] input format // [3] param value // [4] error message internal void CanEvaluateInvalidParameters(string command, MockTemplateInfo[] templates, string?[][] expectedInvalidParams) { TemplateGroup templateGroup = TemplateGroup.FromTemplateList( CliTemplateInfo.FromTemplateInfo(templates, A.Fake <IHostSpecificDataLoader>())) .Single(); ITemplateEngineHost host = TestHost.GetVirtualHost(); IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true); TemplatePackageManager templatePackageManager = A.Fake <TemplatePackageManager>(); NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host, _ => new TelemetryLogger(null, false), new NewCommandCallbacks()); var parseResult = myCommand.Parse($" new {command}"); var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult)); var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake <TemplatePackageManager>(), templateGroup); Assert.Empty(templateCommands); var templateMatchInfos = InstantiateCommand.CollectTemplateMatchInfo(args, settings, templatePackageManager, templateGroup); var invalidOptions = InstantiateCommand.GetInvalidOptions(templateMatchInfos); Assert.Equal(expectedInvalidParams.Length, invalidOptions.Count); foreach (var invalidParam in expectedInvalidParams) { InvalidTemplateOptionResult.Kind expectedErrorKind = invalidParam[0] == "name" ? InvalidTemplateOptionResult.Kind.InvalidName : InvalidTemplateOptionResult.Kind.InvalidValue; string?expectedCanonicalName = invalidParam[1]; string expectedInputFormat = invalidParam[2] ?? throw new Exception("Input Format cannot be null"); string?expectedSpecifiedValue = invalidParam[3]; string?expectedErrorMessage = null; if (invalidParam.Length == 5) { expectedErrorMessage = invalidParam[4]; } var actualParam = invalidOptions.Single(param => param.InputFormat == expectedInputFormat); Assert.Equal(expectedErrorKind, actualParam.ErrorKind); Assert.Equal(expectedCanonicalName, actualParam.TemplateOption?.TemplateParameter.Name); Assert.Equal(expectedInputFormat, actualParam.InputFormat); Assert.Equal(expectedSpecifiedValue, actualParam.SpecifiedValue); Assert.Equal(expectedErrorMessage, actualParam.ErrorMessage); } }