public static bool TryGetRuntimeValue(this IParameterSet parameters, IEngineEnvironmentSettings environmentSettings, string name, out object value, bool skipEnvironmentVariableSearch = false)
{
if (parameters.TryGetParameterDefinition(name, out ITemplateParameter param) &&
parameters.ResolvedValues.TryGetValue(param, out object newValueObject) &&
newValueObject != null)
{
value = newValueObject;
return(true);
}
if ((environmentSettings.Host.TryGetHostParamDefault(name, out string newValue) && newValue != null) ||
(!skipEnvironmentVariableSearch && environmentSettings.Environment.GetEnvironmentVariables().TryGetValue(name, out newValue) && newValue != null))
{
value = newValue;
return(true);
}
value = null;
return(false);
}
// For creating descriptors.
public static bool TryCreateFromMountPoint(IEngineEnvironmentSettings environmentSettings, IMountPoint mountPoint, out IReadOnlyList <IInstallUnitDescriptor> descriptorList)
{
IInstallUnitDescriptorFactory defaultFactory = null;
foreach (IInstallUnitDescriptorFactory factory in environmentSettings.SettingsLoader.Components.OfType <IInstallUnitDescriptorFactory>().ToList())
{
if (factory is DefaultInstallUnitDescriptorFactory)
{
defaultFactory = factory;
continue;
}
if (factory.TryCreateFromMountPoint(mountPoint, out descriptorList))
{
return(true);
}
}
return(defaultFactory.TryCreateFromMountPoint(mountPoint, out descriptorList));
}
public async Task CannotInstall_NotExist()
{
MockInstallerFactory factory = new MockInstallerFactory();
MockManagedTemplatePackageProvider provider = new MockManagedTemplatePackageProvider();
IEngineEnvironmentSettings engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
FolderInstaller folderInstaller = new FolderInstaller(engineEnvironmentSettings, factory);
InstallRequest request = new InstallRequest("not found");
Assert.False(await folderInstaller.CanInstallAsync(request, CancellationToken.None).ConfigureAwait(false));
InstallResult result = await folderInstaller.InstallAsync(request, provider, CancellationToken.None).ConfigureAwait(false);
Assert.False(result.Success);
Assert.Equal(request, result.InstallRequest);
Assert.Equal(InstallerErrorCode.PackageNotFound, result.Error);
result.ErrorMessage.Should().NotBeNullOrEmpty();
result.TemplatePackage.Should().BeNull();
}
public void CanReadDescription(string fileContent, bool errorExpected, string?expectedDescription)
{
IEngineEnvironmentSettings environmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
string tempFolder = _environmentSettingsHelper.CreateTemporaryFolder();
string localizationFile = string.Format(DefaultLocalizeConfigRelativePath, "de-DE");
WriteFile(Path.Combine(tempFolder, localizationFile), fileContent, environmentSettings);
using IMountPoint mountPoint = GetMountPointForPath(tempFolder, environmentSettings);
if (!errorExpected)
{
var localizationModel = LocalizationModelDeserializer.Deserialize(mountPoint.FileInfo(localizationFile) !);
Assert.NotNull(localizationModel);
Assert.Equal(expectedDescription, localizationModel.Description);
}
else
{
Assert.ThrowsAny <Exception>(() => LocalizationModelDeserializer.Deserialize(mountPoint.FileInfo(localizationFile) !));
}
}
public async Task CanProcessDifferentVersions(string configuredVersion, string hostVersion, bool expectedResult)
{
var config = new
{
identity = "test",
constraints = new
{
host = new
{
type = "host",
args = new[]
{
new
{
hostName = "host1",
version = configuredVersion
}
}
}
}
};
var configModel = SimpleConfigModel.FromJObject(JObject.FromObject(config));
IEngineEnvironmentSettings settings = A.Fake <IEngineEnvironmentSettings>();
A.CallTo(() => settings.Host.HostIdentifier).Returns("host1");
A.CallTo(() => settings.Host.Version).Returns(hostVersion);
A.CallTo(() => settings.Components.OfType <ITemplateConstraintFactory>()).Returns(new[] { new HostConstraintFactory() });
var constraintManager = new TemplateConstraintManager(settings);
var evaluateResult = await constraintManager.EvaluateConstraintAsync(configModel.Constraints.Single().Type, configModel.Constraints.Single().Args, default).ConfigureAwait(false);
if (expectedResult)
{
Assert.Equal(TemplateConstraintResult.Status.Allowed, evaluateResult.EvaluationStatus);
}
else
{
Assert.Equal(TemplateConstraintResult.Status.Restricted, evaluateResult.EvaluationStatus);
}
}
public void CanReadFilenameReplacementConfig()
{
string configContent = @"
{
""identity"": ""test"",
""symbols"": {
""testparam"": {
""type"": ""parameter"",
""datatype"": ""string"",
""fileRename"": ""testparamfilereplacement""
},
""testgenerated"": {
""type"": ""generated"",
""generator"": ""casing"",
""parameters"": {
""source"": ""name"",
""toLower"": true
},
""fileRename"": ""testgeneratedfilereplacement""
},
""testgenerated2"": {
""type"": ""generated"",
""generator"": ""casing"",
""parameters"": {
""source"": ""name"",
""toLower"": true
},
""replace"": ""testgeneratedreplacement""
},
}
}
";
SimpleConfigModel configModel = SimpleConfigModel.FromJObject(JObject.Parse(configContent));
IEngineEnvironmentSettings environment = _environmentSettingsHelper.CreateEnvironment();
RunnableProjectConfig runnableConfig =
new RunnableProjectConfig(environment, A.Fake <IGenerator>(), configModel);
Assert.Equal(2, runnableConfig.SymbolFilenameReplacements.Count);
Assert.Equal("testparamfilereplacement", runnableConfig.SymbolFilenameReplacements.Single(x => x.VariableName.Contains("testparam")).OriginalValue.Value);
Assert.Equal("testgeneratedfilereplacement", runnableConfig.SymbolFilenameReplacements.Single(x => x.VariableName == "testgenerated").OriginalValue.Value);
}
public bool Process(IEngineEnvironmentSettings environment, IPostAction actionConfig, ICreationResult templateCreationResult, string outputBasePath)
{
if (templateCreationResult.PrimaryOutputs.Count == 0)
{
environment.Host.LogMessage(LocalizableStrings.NoPrimaryOutputsToRestore);
return(true);
}
bool allSucceeded = true;
foreach (ICreationPath output in templateCreationResult.PrimaryOutputs)
{
string pathToRestore = !string.IsNullOrEmpty(outputBasePath) ? Path.Combine(outputBasePath, output.Path) : output.Path;
if (string.IsNullOrEmpty(pathToRestore) || (!Directory.Exists(pathToRestore) && !Path.GetExtension(pathToRestore).EndsWith("proj", StringComparison.OrdinalIgnoreCase)))
{
continue;
}
Dotnet restoreCommand = Dotnet.Restore(pathToRestore);
restoreCommand.CaptureStdOut();
restoreCommand.CaptureStdErr();
environment.Host.LogMessage(string.Format(LocalizableStrings.RunningDotnetRestoreOn, pathToRestore));
Dotnet.Result commandResult = restoreCommand.Execute();
if (commandResult.ExitCode != 0)
{
environment.Host.LogMessage(LocalizableStrings.RestoreFailed);
environment.Host.LogMessage(string.Format(LocalizableStrings.CommandOutput, commandResult.StdOut + Environment.NewLine + Environment.NewLine + commandResult.StdErr));
environment.Host.LogMessage(string.Empty);
allSucceeded = false;
}
else
{
environment.Host.LogMessage(LocalizableStrings.RestoreSucceeded);
}
}
return(allSucceeded);
}
public IMacroConfig CreateConfig(IEngineEnvironmentSettings environmentSettings, IMacroConfig rawConfig)
{
GeneratedSymbolDeferredMacroConfig deferredConfig = rawConfig as GeneratedSymbolDeferredMacroConfig;
if (deferredConfig == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as a SwitchMacroConfig");
}
string evaluator = null;
if (deferredConfig.Parameters.TryGetValue("evaluator", out JToken evaluatorToken))
{
evaluator = evaluatorToken.ToString();
}
string dataType = null;
if (deferredConfig.Parameters.TryGetValue("datatype", out JToken dataTypeToken))
{
dataType = dataTypeToken.ToString();
}
List <KeyValuePair <string, string> > switchList = new List <KeyValuePair <string, string> >();
if (deferredConfig.Parameters.TryGetValue("cases", out JToken switchListToken))
{
JArray switchJArray = (JArray)switchListToken;
foreach (JToken switchInfo in switchJArray)
{
JObject map = (JObject)switchInfo;
string condition = map.ToString("condition");
string value = map.ToString("value");
switchList.Add(new KeyValuePair <string, string>(condition, value));
}
}
IMacroConfig realConfig = new SwitchMacroConfig(deferredConfig.VariableName, evaluator, dataType, switchList);
return(realConfig);
}
public void CopyOnlyWithoutIncludeDoesntHappen()
{
IEngineEnvironmentSettings environment = TemplateConfigTestHelpers.GetTestEnvironment();
string sourceBasePath = FileSystemHelpers.GetNewVirtualizedPath(environment);
TestTemplateSetup setup = SetupCopyOnlyTemplate(environment, sourceBasePath);
string targetDir = FileSystemHelpers.GetNewVirtualizedPath(environment);
IReadOnlyDictionary <string, IReadOnlyList <IFileChange> > allChanges = setup.GetFileChanges(targetDir);
// one source, should cause one set of changes
Assert.Equal(1, allChanges.Count);
if (!allChanges.TryGetValue("./", out IReadOnlyList <IFileChange> changes))
{
Assert.True(false, "no changes for source './'");
}
Assert.Equal(1, changes.Count);
Assert.Equal(ChangeKind.Create, changes[0].ChangeKind);
Assert.True(string.Equals(changes[0].TargetRelativePath, "something.txt"), "didn't copy the correct file");
}
public Task <ICreationResult> CreateAsync(
IEngineEnvironmentSettings environmentSettings,
ITemplate templateData,
IParameterSet parameters,
string targetDirectory,
CancellationToken cancellationToken)
{
RunnableProjectConfig templateConfig = (RunnableProjectConfig)templateData;
if (templateData.TemplateSourceRoot is null)
{
throw new InvalidOperationException($"{nameof(templateData.TemplateSourceRoot)} cannot be null to continue.");
}
return(CreateAsync(
environmentSettings,
templateConfig,
templateData.TemplateSourceRoot,
parameters,
targetDirectory,
cancellationToken));
}
public NuGetInstaller(IInstallerFactory factory, IEngineEnvironmentSettings settings, string installPath)
{
Factory = factory ?? throw new ArgumentNullException(nameof(factory));
_environmentSettings = settings ?? throw new ArgumentNullException(nameof(settings));
_logger = settings.Host.LoggerFactory.CreateLogger <NuGetInstaller>();
if (string.IsNullOrWhiteSpace(installPath))
{
throw new ArgumentException($"{nameof(installPath)} should not be null or empty", nameof(installPath));
}
if (!_environmentSettings.Host.FileSystem.DirectoryExists(installPath))
{
_environmentSettings.Host.FileSystem.CreateDirectory(installPath);
}
_installPath = installPath;
NuGetApiPackageManager packageManager = new NuGetApiPackageManager(settings);
_packageDownloader = packageManager;
_updateChecker = packageManager;
}
public static bool TryReadDiscoveryMetadata(IEngineEnvironmentSettings environment, ISearchCacheConfig config, out TemplateDiscoveryMetadata discoveryMetadata)
{
Paths paths = new Paths(environment);
string pathToConfig = Path.Combine(paths.User.BaseDir, config.TemplateDiscoveryFileName);
string cacheText = paths.ReadAllText(pathToConfig);
JObject cacheObject = JObject.Parse(cacheText);
// add the reader calls, build the model objects
if (TryReadVersion(cacheObject, out string version) &&
TryReadTemplateList(cacheObject, version, out IReadOnlyList <ITemplateInfo> templateList) &&
TryReadPackToTemplateMap(cacheObject, out IReadOnlyDictionary <string, PackToTemplateEntry> packToTemplateMap) &&
TryReadAdditionalData(cacheObject, config.AdditionalDataReaders, out IReadOnlyDictionary <string, object> additionalDta))
{
discoveryMetadata = new TemplateDiscoveryMetadata(version, templateList, packToTemplateMap, additionalDta);
return(true);
}
discoveryMetadata = null;
return(false);
}
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
string value = null;
RegexMacroConfig config = rawConfig as RegexMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as RegexMacroConfig");
}
if (!vars.TryGetValue(config.SourceVariable, out object working))
{
if (parameters.TryGetRuntimeValue(environmentSettings, config.SourceVariable, out object resolvedValue, true))
{
value = resolvedValue.ToString();
}
else
{
value = string.Empty;
}
}
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
RandomMacroConfig config = rawConfig as RandomMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as RandomMacroConfig");
}
Random rnd = new Random();
int value = rnd.Next(config.Low, config.High);
Parameter p = new Parameter
{
IsVariable = true,
Name = config.VariableName
};
vars[config.VariableName] = value.ToString();
setter(p, value.ToString());
}
public async Task GetLatestVersion_Success()
{
MockInstallerFactory factory = new MockInstallerFactory();
MockManagedTemplatePackageProvider provider = new MockManagedTemplatePackageProvider();
IEngineEnvironmentSettings engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
FolderInstaller folderInstaller = new FolderInstaller(engineEnvironmentSettings, factory);
FolderManagedTemplatePackage source = new FolderManagedTemplatePackage(engineEnvironmentSettings, folderInstaller, provider, Path.GetRandomFileName());
IReadOnlyList <CheckUpdateResult> results = await folderInstaller.GetLatestVersionAsync(new[] { source }, provider, CancellationToken.None).ConfigureAwait(false);
Assert.Single(results);
CheckUpdateResult result = results.Single();
Assert.True(result.Success);
Assert.Equal(source, result.TemplatePackage);
Assert.Equal(InstallerErrorCode.Success, result.Error);
result.ErrorMessage.Should().BeNullOrEmpty();
result.LatestVersion.Should().BeNullOrEmpty();
Assert.True(result.IsLatestVersion);
}
public async Task Update_Success()
{
MockInstallerFactory factory = new MockInstallerFactory();
MockManagedTemplatePackageProvider provider = new MockManagedTemplatePackageProvider();
IEngineEnvironmentSettings engineEnvironmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
FolderInstaller folderInstaller = new FolderInstaller(engineEnvironmentSettings, factory);
FolderManagedTemplatePackage source = new FolderManagedTemplatePackage(engineEnvironmentSettings, folderInstaller, provider, Path.GetRandomFileName(), DateTime.UtcNow);
//add a delay so update updates last changed time
await Task.Delay(100).ConfigureAwait(false);
UpdateRequest updateRequest = new UpdateRequest(source, "1.0.0");
UpdateResult result = await folderInstaller.UpdateAsync(updateRequest, provider, CancellationToken.None).ConfigureAwait(false);
Assert.True(result.Success);
Assert.Equal(updateRequest, result.UpdateRequest);
Assert.Equal(InstallerErrorCode.Success, result.Error);
Assert.Equal(source.MountPointUri, result.TemplatePackage.MountPointUri);
Assert.NotEqual(source.LastChangeTime, result.TemplatePackage.LastChangeTime);
}
public void CanReadFilenameReplacementConfig()
{
string configContent = @"
{
""symbols"": {
""testparam"": {
""type"": ""parameter"",
""datatype"": ""string"",
""fileRename"": ""testparamfilereplacement""
},
""testgenerated"": {
""type"": ""generated"",
""generator"": ""casing"",
""parameters"": {
""source"": ""name"",
""toLower"": true
},
""fileRename"": ""testgeneratedfilereplacement""
},
""testgenerated2"": {
""type"": ""generated"",
""generator"": ""casing"",
""parameters"": {
""source"": ""name"",
""toLower"": true
},
""replace"": ""testgeneratedreplacement""
},
}
}
";
IEngineEnvironmentSettings environment = TemplateConfigTestHelpers.GetTestEnvironment();
JObject configJson = JObject.Parse(configContent);
SimpleConfigModel config = SimpleConfigModel.FromJObject(environment, configJson);
Assert.Equal(2, config.SymbolFilenameReplacements.Count);
Assert.Equal("testparamfilereplacement", config.SymbolFilenameReplacements.Single(x => x.VariableName.Contains("testparam")).OriginalValue.Value);
Assert.Equal("testgeneratedfilereplacement", config.SymbolFilenameReplacements.Single(x => x.VariableName == "testgenerated").OriginalValue.Value);
}
public static bool TryParse(IEngineEnvironmentSettings environmentSettings, JObject descriptorObj, out IInstallUnitDescriptor parsedDescriptor)
{
if (descriptorObj == null)
{
parsedDescriptor = null;
return(false);
}
if (!descriptorObj.TryGetValue(nameof(IInstallUnitDescriptor.FactoryId), StringComparison.OrdinalIgnoreCase, out JToken factoryIdToken) ||
(factoryIdToken == null) ||
(factoryIdToken.Type != JTokenType.String) ||
!Guid.TryParse(factoryIdToken.ToString(), out Guid factoryId) ||
!environmentSettings.SettingsLoader.Components.TryGetComponent(factoryId, out IInstallUnitDescriptorFactory factory))
{
parsedDescriptor = null;
return(false);
}
Dictionary <string, string> details = new Dictionary <string, string>();
foreach (JProperty property in descriptorObj.PropertiesOf(nameof(IInstallUnitDescriptor.Details)))
{
if (property.Value.Type != JTokenType.String)
{
parsedDescriptor = null;
return(false);
}
details[property.Name] = property.Value.ToString();
}
if (factory.TryCreateFromDetails(details, out IInstallUnitDescriptor descriptor))
{
parsedDescriptor = descriptor;
return(true);
}
parsedDescriptor = null;
return(false);
}
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
NowMacroConfig config = rawConfig as NowMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as NowMacroConfig");
}
DateTime time = config.Utc ? DateTime.UtcNow : DateTime.Now;
string value = time.ToString(config.Format);
Parameter p;
if (parameters.TryGetParameterDefinition(config.VariableName, out ITemplateParameter existingParam))
{
// If there is an existing parameter with this name, it must be reused so it can be referenced by name
// for other processing, for example: if the parameter had value forms defined for creating variants.
// When the param already exists, use its definition, but set IsVariable = true for consistency.
p = (Parameter)existingParam;
p.IsVariable = true;
if (string.IsNullOrEmpty(p.DataType))
{
p.DataType = config.DataType;
}
}
else
{
p = new Parameter
{
IsVariable = true,
Name = config.VariableName,
DataType = config.DataType
};
}
vars[config.VariableName] = value;
setter(p, value);
}
internal static Task <CreationResultStatus> CoordinateAmbiguousTemplateResolutionDisplayAsync(
TemplateResolutionResult resolutionResult,
IEngineEnvironmentSettings environmentSettings,
INewCommandInput commandInput,
string?defaultLanguage)
{
switch (resolutionResult.ResolutionStatus)
{
case TemplateResolutionResult.Status.NoMatch:
Reporter.Error.WriteLine(
string.Format(LocalizableStrings.NoTemplatesMatchingInputParameters, GetInputParametersString(commandInput)).Bold().Red());
Reporter.Error.WriteLine(string.Format(LocalizableStrings.ListTemplatesCommand, commandInput.CommandName).Bold().Red());
Reporter.Error.WriteLine(string.Format(LocalizableStrings.SearchTemplatesCommand, commandInput.CommandName, commandInput.TemplateName).Bold().Red());
return(Task.FromResult(CreationResultStatus.NotFound));
case TemplateResolutionResult.Status.AmbiguousLanguageChoice:
Reporter.Error.WriteLine(LocalizableStrings.AmbiguousTemplateGroupListHeader.Bold().Red());
DisplayTemplateList(resolutionResult.TemplateGroups, environmentSettings, commandInput, defaultLanguage, useErrorOutput: true);
Reporter.Error.WriteLine(LocalizableStrings.AmbiguousLanguageHint.Bold().Red());
return(Task.FromResult(CreationResultStatus.NotFound));
case TemplateResolutionResult.Status.AmbiguousTemplateGroupChoice:
Reporter.Error.WriteLine(LocalizableStrings.AmbiguousTemplateGroupListHeader.Bold().Red());
DisplayTemplateList(resolutionResult.TemplateGroups, environmentSettings, commandInput, defaultLanguage, useErrorOutput: true);
Reporter.Error.WriteLine(LocalizableStrings.AmbiguousTemplateGroupListHint.Bold().Red());
return(Task.FromResult(CreationResultStatus.NotFound));
case TemplateResolutionResult.Status.AmbiguousParameterValueChoice:
environmentSettings.Host.LogDiagnosticMessage(LocalizableStrings.Authoring_AmbiguousChoiceParameterValue, "Authoring");
return(Task.FromResult(DisplayInvalidParameterError(resolutionResult.UnambiguousTemplateGroup, commandInput)));
case TemplateResolutionResult.Status.AmbiguousTemplateChoice:
environmentSettings.Host.LogDiagnosticMessage(LocalizableStrings.Authoring_AmbiguousBestPrecedence, "Authoring");
return(DisplayAmbiguousPrecedenceErrorAsync(resolutionResult.UnambiguousTemplateGroup, environmentSettings, commandInput));
case TemplateResolutionResult.Status.InvalidParameter:
return(Task.FromResult(DisplayInvalidParameterError(resolutionResult.UnambiguousTemplateGroup, commandInput)));
}
return(Task.FromResult(CreationResultStatus.CreateFailed));
}
public void CanReadNonChoiceSymbol(
string fileContent,
bool errorExpected,
string expectedSymbolNamesStr,
string expectedSymbolDisplayNamesStr,
string expectedDescriptionsStr)
{
IEngineEnvironmentSettings environmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
string tempFolder = _environmentSettingsHelper.CreateTemporaryFolder();
string localizationFile = string.Format(DefaultLocalizeConfigRelativePath, "de-DE");
WriteFile(Path.Combine(tempFolder, localizationFile), fileContent, environmentSettings);
using IMountPoint mountPoint = GetMountPointForPath(tempFolder, environmentSettings);
if (!errorExpected)
{
var localizationModel = LocalizationModelDeserializer.Deserialize(mountPoint.FileInfo(localizationFile) !);
Assert.NotNull(localizationModel);
if (string.IsNullOrEmpty(expectedSymbolNamesStr))
{
Assert.Empty(localizationModel.ParameterSymbols);
return;
}
var expectedSymbolNames = expectedSymbolNamesStr.Split('|');
var expectedDisplayNames = expectedSymbolDisplayNamesStr.Split('|');
var expectedDescriptions = expectedDescriptionsStr.Split('|');
for (int i = 0; i < expectedSymbolNames.Length; i++)
{
Assert.True(localizationModel.ParameterSymbols.ContainsKey(expectedSymbolNames[i]));
Assert.Equal(expectedDisplayNames[i] == "(null)" ? null : expectedDisplayNames[i], localizationModel.ParameterSymbols[expectedSymbolNames[i]].DisplayName);
Assert.Equal(expectedDescriptions[i] == "(null)" ? null : expectedDescriptions[i], localizationModel.ParameterSymbols[expectedSymbolNames[i]].Description);
}
}
else
{
Assert.ThrowsAny <Exception>(() => LocalizationModelDeserializer.Deserialize(mountPoint.FileInfo(localizationFile) !));
}
}
/// <summary>
/// Performs the dry-run of the template instantiation to evaluate the primary outputs, post actions to be applied and file changes to be made when executing the template with specified parameters.
/// </summary>
/// <param name="environmentSettings">environment settings</param>
/// <param name="templateData">the template to be executed</param>
/// <param name="parameters">the parameters to be used on template execution</param>
/// <param name="componentManager">the instance of component manager</param>
/// <param name="targetDirectory">the output path for the template</param>
/// <returns>the primary outputs, post actions and file changes that will be made when executing the template with specified parameters.</returns>
public ICreationEffects GetCreationEffects(IEngineEnvironmentSettings environmentSettings, ITemplate templateData, IParameterSet parameters, IComponentManager componentManager, string targetDirectory)
{
RunnableProjectTemplate template = (RunnableProjectTemplate)templateData;
ProcessMacros(environmentSettings, componentManager, template.Config.OperationConfig, parameters);
IVariableCollection variables = VariableCollection.SetupVariables(environmentSettings, parameters, template.Config.OperationConfig.VariableSetup);
template.Config.Evaluate(parameters, variables, template.ConfigFile);
IOrchestrator2 basicOrchestrator = new Core.Util.Orchestrator();
RunnableProjectOrchestrator orchestrator = new RunnableProjectOrchestrator(basicOrchestrator);
GlobalRunSpec runSpec = new GlobalRunSpec(template.TemplateSourceRoot, componentManager, parameters, variables, template.Config.OperationConfig, template.Config.SpecialOperationConfig, template.Config.LocalizationOperations, template.Config.IgnoreFileNames);
List <IFileChange2> changes = new List <IFileChange2>();
foreach (FileSourceMatchInfo source in template.Config.Sources)
{
runSpec.SetupFileSource(source);
string target = Path.Combine(targetDirectory, source.Target);
IReadOnlyList <IFileChange2> fileChanges = orchestrator.GetFileChanges(runSpec, template.TemplateSourceRoot.DirectoryInfo(source.Source), target);
//source and target paths in the file changes are returned relative to source passed
//GetCreationEffects method should return the source paths relative to template source root (location of .template.config folder) and target paths relative to output path and not relative to certain source
//add source and target used to file changes to be returned as the result
changes.AddRange(
fileChanges.Select(
fileChange => new FileChange(
Path.Combine(source.Source, fileChange.SourceRelativePath),
Path.Combine(source.Target, fileChange.TargetRelativePath),
fileChange.ChangeKind,
fileChange.Contents)));
}
return(new CreationEffects2
{
FileChanges = changes,
CreationResult = GetCreationResult(environmentSettings, template, variables)
});
}
// The project files to add are a subset of the primary outputs, specifically the primary outputs indicated by the primaryOutputIndexes post action arg (semicolon separated)
// If any indexes are out of range or non-numeric, thsi method returns false and projectFiles is set to null.
internal static bool TryGetProjectFilesToAdd(IEngineEnvironmentSettings environment, IPostAction actionConfig, ICreationResult templateCreationResult, string outputBasePath, out IReadOnlyList <string> projectFiles)
{
List <string> filesToAdd = new List <string>();
if ((actionConfig.Args != null) && actionConfig.Args.TryGetValue("primaryOutputIndexes", out string projectIndexes))
{
foreach (string indexString in projectIndexes.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
if (int.TryParse(indexString.Trim(), out int index))
{
if (templateCreationResult.PrimaryOutputs.Count <= index || index < 0)
{
projectFiles = null;
return(false);
}
filesToAdd.Add(Path.Combine(outputBasePath, templateCreationResult.PrimaryOutputs[index].Path));
}
else
{
projectFiles = null;
return(false);
}
}
projectFiles = filesToAdd;
return(true);
}
else
{
foreach (string pathString in templateCreationResult.PrimaryOutputs.Select(x => x.Path))
{
filesToAdd.Add(!string.IsNullOrEmpty(outputBasePath) ? Path.Combine(outputBasePath, pathString) : pathString);
}
projectFiles = filesToAdd;
return(true);
}
}
public static CreationResultStatus DisplayAliasValues(IEngineEnvironmentSettings environment, INewCommandInput commandInput, AliasRegistry aliasRegistry, string commandName)
{
IReadOnlyDictionary <string, IReadOnlyList <string> > aliasesToShow;
if (!string.IsNullOrEmpty(commandInput.ShowAliasesAliasName))
{
if (aliasRegistry.AllAliases.TryGetValue(commandInput.ShowAliasesAliasName, out IReadOnlyList <string> aliasValue))
{
aliasesToShow = new Dictionary <string, IReadOnlyList <string> >()
{
{ commandInput.ShowAliasesAliasName, aliasValue }
};
}
else
{
Reporter.Output.WriteLine(string.Format(LocalizableStrings.AliasShowErrorUnknownAlias, commandInput.ShowAliasesAliasName, commandName));
return(CreationResultStatus.InvalidParamValues);
}
}
else
{
aliasesToShow = aliasRegistry.AllAliases;
Reporter.Output.WriteLine(LocalizableStrings.AliasShowAllAliasesHeader);
}
HelpFormatter <KeyValuePair <string, IReadOnlyList <string> > > formatter =
new HelpFormatter <KeyValuePair <string, IReadOnlyList <string> > >(
environment,
commandInput,
aliasesToShow,
columnPadding: 2,
headerSeparator: '-',
blankLineBetweenRows: false)
.DefineColumn(t => t.Key, LocalizableStrings.AliasName, showAlways: true)
.DefineColumn(t => string.Join(" ", t.Value), LocalizableStrings.AliasValue, showAlways: true);
Reporter.Output.WriteLine(formatter.Layout());
return(CreationResultStatus.Success);
}
// Creates and returns the processor used to create the file rename mapping.
private static IProcessor SetupRenameProcessor(IEngineEnvironmentSettings environmentSettings, IReadOnlyDictionary <string, string> substringReplacementMap, IReadOnlyDictionary <string, string> fileRenames)
{
List <IOperationProvider> operations = new List <IOperationProvider>();
foreach (KeyValuePair <string, string> replacement in fileRenames)
{
IOperationProvider replacementOperation = new Replacement(replacement.Key.TokenConfig(), replacement.Value, null, true);
operations.Add(replacementOperation);
}
foreach (KeyValuePair <string, string> replacement in substringReplacementMap)
{
IOperationProvider replacementOperation = new Replacement(replacement.Key.TokenConfig(), replacement.Value, null, true);
operations.Add(replacementOperation);
}
IVariableCollection variables = new VariableCollection();
EngineConfig config = new EngineConfig(environmentSettings, variables);
IProcessor processor = Processor.Create(config, operations);
return(processor);
}
/// <summary>
/// Returns absolute path to files or folders resolved from <paramref name="maskedPath"/>.
/// </summary>
/// <remarks>
/// Example of <paramref name="maskedPath"/> would be "C:\Users\username\packages\*.nupkg".<br/>
/// Wildcards are supported only in file name.
/// Supported wildcards and rules are identical as for <see cref="searchPattern"/> for <see cref="Directory.EnumerateDirectories(string, string)"/>.
/// </remarks>
/// <param name="maskedPath">This parameter can contain a wildcard (*) character in the filename.</param>
/// <param name="environmentSettings"></param>
/// <returns>List of absolute paths to files or folders that match <paramref name="maskedPath"/>.</returns>
public static IEnumerable <string> ExpandMaskedPath(string maskedPath, IEngineEnvironmentSettings environmentSettings)
{
if (maskedPath.IndexOfAny(Path.GetInvalidPathChars()) != -1)
{
yield return(maskedPath);
yield break;
}
var matches = DetermineDirectoriesToScan(maskedPath, environmentSettings).ToList();
//This can happen when user specifies "PackageId"
if (matches.Count == 0)
{
yield return(maskedPath);
yield break;
}
foreach (var path in matches)
{
yield return(Path.GetFullPath(path));
}
}
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
EvaluateMacroConfig config = rawConfig as EvaluateMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as EvaluateMacroConfig");
}
ConditionEvaluator evaluator = EvaluatorSelector.Select(config.Evaluator, Cpp2StyleEvaluatorDefinition.Evaluate);
byte[] data = Encoding.UTF8.GetBytes(config.Value);
int len = data.Length;
int pos = 0;
IProcessorState state = new GlobalRunSpec.ProcessorState(environmentSettings, vars, data, Encoding.UTF8);
bool result = evaluator(state, ref len, ref pos, out bool faulted);
Parameter p;
if (parameters.TryGetParameterDefinition(config.VariableName, out ITemplateParameter existingParam))
{
// If there is an existing parameter with this name, it must be reused so it can be referenced by name
// for other processing, for example: if the parameter had value forms defined for creating variants.
// When the param already exists, use its definition, but set IsVariable = true for consistency.
p = (Parameter)existingParam;
p.IsVariable = true;
}
else
{
p = new Parameter
{
IsVariable = true,
Name = config.VariableName
};
}
vars[config.VariableName] = result.ToString();
setter(p, result.ToString());
}
public void CanValidatePostActionWithoutLocalization()
{
IEngineEnvironmentSettings environmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true);
string tempFolder = _environmentSettingsHelper.CreateTemporaryFolder();
string localizationFile = string.Format(DefaultLocalizeConfigRelativePath, "de-DE");
WriteFile(Path.Combine(tempFolder, localizationFile), "{ \"postActions/pa0/description\": \"localizedDescription\" }", environmentSettings);
using IMountPoint mountPoint = GetMountPointForPath(tempFolder, environmentSettings);
SimpleConfigModel baseConfig = new SimpleConfigModel()
{
Identity = "Test",
PostActionModels = new List <PostActionModel>
{
new PostActionModel()
{
Id = "",
Description = "text",
ActionId = Guid.NewGuid()
},
new PostActionModel()
{
Id = "pa0",
Description = "text",
ActionId = Guid.NewGuid()
},
}
};
var runnableProjectConfig = new RunnableProjectConfig(environmentSettings, A.Fake <IGenerator>(), baseConfig);
var localizationModel = LocalizationModelDeserializer.Deserialize(mountPoint.FileInfo(localizationFile) !);
Assert.True(runnableProjectConfig.VerifyLocalizationModel(localizationModel));
runnableProjectConfig.ConfigurationModel.Localize(localizationModel);
runnableProjectConfig.PostActionModels.Single(model => model.Id == "pa0" && model.Description == "localizedDescription");
runnableProjectConfig.PostActionModels.Single(model => model.Id != "pa0" && model.Description == "text");
}
internal static IReadOnlyDictionary <string, string> AugmentFileRenames(
IEngineEnvironmentSettings environmentSettings,
string?sourceName,
IFileSystemInfo configFile,
string sourceDirectory,
ref string targetDirectory,
object?resolvedNameParamValue,
IParameterSet parameterSet,
Dictionary <string, string> fileRenames,
IReadOnlyList <IReplacementTokens>?symbolBasedFileRenames = null)
{
Dictionary <string, string> allRenames = new Dictionary <string, string>(StringComparer.Ordinal);
IProcessor sourceRenameProcessor = SetupRenameProcessor(environmentSettings, fileRenames);
IProcessor symbolRenameProcessor = SetupSymbolBasedRenameProcessor(environmentSettings, sourceName, ref targetDirectory, resolvedNameParamValue, parameterSet, symbolBasedFileRenames);
IDirectory?sourceBaseDirectoryInfo = configFile.Parent?.Parent?.DirectoryInfo(sourceDirectory.TrimEnd('/'));
if (sourceBaseDirectoryInfo is null)
{
return(allRenames);
}
foreach (IFileSystemInfo fileSystemEntry in sourceBaseDirectoryInfo.EnumerateFileSystemInfos("*", SearchOption.AllDirectories))
{
string sourceTemplateRelativePath = fileSystemEntry.PathRelativeTo(sourceBaseDirectoryInfo);
// first apply the sources renames, then apply the symbol renames to that result.
string renameFromSourcesValue = ApplyRenameProcessorToFilename(sourceRenameProcessor, sourceTemplateRelativePath);
string renameFinalTargetValue = ApplyRenameProcessorToFilename(symbolRenameProcessor, renameFromSourcesValue);
if (!string.Equals(sourceTemplateRelativePath, renameFinalTargetValue, StringComparison.Ordinal))
{
allRenames[sourceTemplateRelativePath] = renameFinalTargetValue;
}
}
return(allRenames);
}
public static VariableCollection VariableCollectionFromParameters(IEngineEnvironmentSettings environmentSettings, IParameterSet parameters, string format)
{
VariableCollection vc = new VariableCollection();
foreach (ITemplateParameter param in parameters.ParameterDefinitions)
{
string key = string.Format(format ?? "{0}", param.Name);
if (!parameters.ResolvedValues.TryGetValue(param, out object value))
{
if (param.Priority != TemplateParameterPriority.Optional && param.Priority != TemplateParameterPriority.Suggested)
{
while (environmentSettings.Host.OnParameterError(param, null, "ParameterValueNotSpecified", out string val))
{
}
parameters.ResolvedValues[param] = value;
}
}
else if (value == null)
{
if (param.Priority != TemplateParameterPriority.Optional && param.Priority != TemplateParameterPriority.Suggested)
{
while (environmentSettings.Host.OnParameterError(param, null, "ParameterValueNull", out string val))
{
}
parameters.ResolvedValues[param] = value;
}
}
else
{
vc[key] = value;
}
}
return(vc);
}
