private static string DetermineTransformFileName(string sourceFile, XmlConfigTransformDefinition transformation, bool defaultExtension)
{
var tp = transformation.TransformPattern;
if (defaultExtension && !tp.EndsWith(".config"))
{
tp += ".config";
}
if (transformation.Advanced && transformation.IsTransformWildcard && transformation.IsSourceWildcard)
{
return(DetermineWildcardTransformFileName(sourceFile, transformation, tp));
}
if (transformation.Advanced && transformation.IsTransformWildcard && !transformation.IsSourceWildcard)
{
var transformDirectory = GetTransformationFileDirectory(sourceFile, transformation);
return(Path.Combine(transformDirectory, GetDirectoryName(tp), "*." + GetFileName(tp).TrimStart('.')));
}
if (transformation.Advanced && !transformation.IsTransformWildcard)
{
var transformDirectory = GetTransformationFileDirectory(sourceFile, transformation);
return(Path.Combine(transformDirectory, tp));
}
return(Path.ChangeExtension(sourceFile, tp));
}
public void DetermineCorrectTransformFileName()
{
foreach (var set in TransformFileNameTestCases)
{
string sourceFile = set.Item1, transformDefinition = set.Item2, required = set.Item3;
var transform = new XmlConfigTransformDefinition(transformDefinition);
var all = ConfigurationTransformsConvention.DetermineTransformFileNames(sourceFile, transform);
var matched = all.Contains(required);
Assert.That(matched);
}
}
static string GetTransformationFileDirectory(string sourceFile, XmlConfigTransformDefinition transformation)
{
var sourceDirectory = GetDirectoryName(sourceFile);
if (!transformation.SourcePattern.Contains(Path.DirectorySeparatorChar))
{
return(sourceDirectory);
}
var sourcePattern = transformation.SourcePattern;
var sourcePatternPath = sourcePattern.Substring(0, sourcePattern.LastIndexOf(Path.DirectorySeparatorChar));
return(sourceDirectory.Replace(sourcePatternPath, string.Empty));
}
private string[] PerformTransform(string sourceFile)
{
fileSystem.EnumerateFiles(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>())
.Returns(callInfo => files.Where(file => FilesMatch(callInfo, file)));
var realFileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
fileSystem.GetRelativePath(Arg.Any <string>(), Arg.Any <string>())
.Returns(x => GetRelativePath(x, realFileSystem));
var transformFileLocator = new TransformFileLocator(fileSystem);
var transform = new XmlConfigTransformDefinition(transformDefinition);
const bool diagnosticLoggingEnabled = false;
var result = transformFileLocator.DetermineTransformFileNames(sourceFile, transform, diagnosticLoggingEnabled).ToArray();
return(result);
}
void ApplyTransformations(string sourceFile, XmlConfigTransformDefinition transformation,
ISet <Tuple <string, string> > transformFilesApplied, ICollection <XmlConfigTransformDefinition> transformDefinitionsApplied)
{
if (transformation == null)
{
return;
}
foreach (var transformFile in DetermineTransformFileNames(sourceFile, transformation))
{
var sourceFileName = (transformation?.SourcePattern?.Contains(Path.DirectorySeparatorChar) ?? false)
? fileSystem.GetRelativePath(transformFile, sourceFile).TrimStart('.', Path.DirectorySeparatorChar)
: GetFileName(sourceFile);
if (transformation.Advanced && !transformation.IsSourceWildcard && !string.Equals(transformation.SourcePattern, sourceFileName, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (transformation.Advanced && transformation.IsSourceWildcard && !DoesFileMatchWildcardPattern(sourceFileName, transformation.SourcePattern))
{
continue;
}
if (!fileSystem.FileExists(transformFile))
{
continue;
}
if (string.Equals(sourceFile, transformFile, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
var transformFiles = new Tuple <string, string>(transformFile, sourceFile);
if (transformFilesApplied.Contains(transformFiles))
{
continue;
}
Log.Info("Transforming '{0}' using '{1}'.", sourceFile, transformFile);
configurationTransformer.PerformTransform(sourceFile, transformFile, sourceFile);
transformFilesApplied.Add(transformFiles);
transformDefinitionsApplied.Add(transformation);
}
}
static string DetermineWildcardTransformFileName(string sourceFile, XmlConfigTransformDefinition transformation, string transformPattern)
{
var sourcePatternWithoutPrefix = GetFileName(transformation.SourcePattern);
if (transformation.SourcePattern.StartsWith("."))
{
sourcePatternWithoutPrefix = transformation.SourcePattern.Remove(0, 1);
}
var transformDirectory = GetTransformationFileDirectory(sourceFile, transformation);
var baseFileName = transformation.IsSourceWildcard ?
GetFileName(sourceFile).Replace(sourcePatternWithoutPrefix, "")
: GetFileName(sourceFile);
var baseTransformPath = Path.Combine(transformDirectory, GetDirectoryName(transformPattern), baseFileName);
return(Path.ChangeExtension(baseTransformPath, GetFileName(transformPattern)));
}
private IEnumerable <string> DetermineTransformFileNames(string sourceFile, XmlConfigTransformDefinition transformation)
{
var defaultTransformFileName = DetermineTransformFileName(sourceFile, transformation, true);
var transformFileName = DetermineTransformFileName(sourceFile, transformation, false);
var relativeTransformPath = fileSystem.GetRelativePath(sourceFile, transformFileName);
var fullTransformPath = Path.GetFullPath(Path.Combine(GetDirectoryName(sourceFile), GetDirectoryName(relativeTransformPath)));
if (!fileSystem.DirectoryExists(fullTransformPath))
{
return(Enumerable.Empty <string>());
}
// The reason we use fileSystem.EnumerateFiles here is to get the actual file-names from the physical file-system.
// This prevents any issues with mis-matched casing in transform specifications.
return(fileSystem.EnumerateFiles(fullTransformPath,
GetFileName(defaultTransformFileName),
GetFileName(transformFileName)
));
}
private string[] PerformTransform(string sourceFile)
{
fileSystem.EnumerateFiles(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>())
.Returns(callInfo => files.Where(file => FilesMatch(callInfo, file)));
var realFileSystem = CalamariPhysicalFileSystem.GetPhysicalFileSystem();
fileSystem.GetRelativePath(Arg.Any <string>(), Arg.Any <string>())
.Returns(x => GetRelativePath(x, realFileSystem));
var transformFileLocator = new TransformFileLocator(fileSystem);
var transform = new XmlConfigTransformDefinition(transformDefinition);
var deploymentVariables = new CalamariVariables();
deploymentVariables[KnownVariables.OriginalPackageDirectoryPath] = extractionDirectory;
var deployment = new RunningDeployment(null, deploymentVariables);
const bool diagnosticLoggingEnabled = false;
var result = transformFileLocator.DetermineTransformFileNames(sourceFile, transform, diagnosticLoggingEnabled, deployment).ToArray();
return(result);
}
private static string DetermineTransformFileName(string sourceFile, XmlConfigTransformDefinition transformation, bool defaultExtension)
{
var tp = transformation.TransformPattern;
if (defaultExtension && !tp.EndsWith(".config"))
{
tp += ".config";
}
if (transformation.Advanced && transformation.Wildcard)
{
var baseFileName = sourceFile.Replace(transformation.SourcePattern, "");
return(Path.ChangeExtension(baseFileName, tp));
}
if (transformation.Advanced && !transformation.Wildcard)
{
return(Path.Combine(Path.GetDirectoryName(sourceFile), tp));
}
return(Path.ChangeExtension(sourceFile, tp));
}
void ApplyTransformations(string sourceFile,
XmlConfigTransformDefinition transformation,
ISet <Tuple <string, string> > transformFilesApplied,
ICollection <XmlConfigTransformDefinition> transformDefinitionsApplied,
ICollection <XmlConfigTransformDefinition> duplicateTransformDefinitions,
bool diagnosticLoggingEnabled,
RunningDeployment deployment)
{
if (transformation == null)
{
return;
}
var transformFileNames = transformFileLocator.DetermineTransformFileNames(sourceFile, transformation, diagnosticLoggingEnabled, deployment)
.Distinct()
.ToArray();
foreach (var transformFile in transformFileNames)
{
var transformFiles = new Tuple <string, string>(transformFile, sourceFile);
if (transformFilesApplied.Contains(transformFiles))
{
if (diagnosticLoggingEnabled)
{
log.Verbose($" - Skipping as target \'{sourceFile}\' has already been transformed by transform \'{transformFile}\'");
}
duplicateTransformDefinitions.Add(transformation);
continue;
}
log.Info($"Transforming '{sourceFile}' using '{transformFile}'.");
configurationTransformer.PerformTransform(sourceFile, transformFile, sourceFile);
transformFilesApplied.Add(transformFiles);
transformDefinitionsApplied.Add(transformation);
}
}
void ApplyTransformations(string sourceFile, XmlConfigTransformDefinition transformation,
ISet <Tuple <string, string> > transformFilesApplied, ICollection <XmlConfigTransformDefinition> transformDefinitionsApplied)
{
if (transformation == null)
{
return;
}
foreach (var transformFile in transformFileLocator.DetermineTransformFileNames(sourceFile, transformation))
{
var transformFiles = new Tuple <string, string>(transformFile, sourceFile);
if (transformFilesApplied.Contains(transformFiles))
{
continue;
}
Log.Info("Transforming '{0}' using '{1}'.", sourceFile, transformFile);
configurationTransformer.PerformTransform(sourceFile, transformFile, sourceFile);
transformFilesApplied.Add(transformFiles);
transformDefinitionsApplied.Add(transformation);
}
}
public static IEnumerable <string> DetermineTransformFileNames(string sourceFile, XmlConfigTransformDefinition transformation)
{
yield return(DetermineTransformFileName(sourceFile, transformation, true));
yield return(DetermineTransformFileName(sourceFile, transformation, false));
}
